sys/netinet/tcp_syncache.c

   1 /*-
   2  * SPDX-License-Identifier: BSD-2-Clause-FreeBSD
   3  *
   4  * Copyright (c) 2001 McAfee, Inc.
   5  * Copyright (c) 2006,2013 Andre Oppermann, Internet Business Solutions AG
   6  * All rights reserved.
   7  *
   8  * This software was developed for the FreeBSD Project by Jonathan Lemon
   9  * and McAfee Research, the Security Research Division of McAfee, Inc. under
  10  * DARPA/SPAWAR contract N66001-01-C-8035 ("CBOSS"), as part of the
  11  * DARPA CHATS research program. [2001 McAfee, Inc.]
  12  *
  13  * Redistribution and use in source and binary forms, with or without
  14  * modification, are permitted provided that the following conditions
  15  * are met:
  16  * 1. Redistributions of source code must retain the above copyright
  17  *    notice, this list of conditions and the following disclaimer.
  18  * 2. Redistributions in binary form must reproduce the above copyright
  19  *    notice, this list of conditions and the following disclaimer in the
  20  *    documentation and/or other materials provided with the distribution.
  21  *
  22  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  23  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  24  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  25  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  26  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  27  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  28  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  29  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  30  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  31  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  32  * SUCH DAMAGE.
  33  */
  34
  35 #include <sys/cdefs.h>
  36 __FBSDID("$FreeBSD$");
  37
  38 #include "opt_inet.h"
  39 #include "opt_inet6.h"
  40 #include "opt_ipsec.h"
  41 #include "opt_pcbgroup.h"
  42
  43 #include <sys/param.h>
  44 #include <sys/systm.h>
  45 #include <sys/hash.h>
  46 #include <sys/refcount.h>
  47 #include <sys/kernel.h>
  48 #include <sys/sysctl.h>
  49 #include <sys/limits.h>
  50 #include <sys/lock.h>
  51 #include <sys/mutex.h>
  52 #include <sys/malloc.h>
  53 #include <sys/mbuf.h>
  54 #include <sys/proc.h>           /* for proc0 declaration */
  55 #include <sys/random.h>
  56 #include <sys/socket.h>
  57 #include <sys/socketvar.h>
  58 #include <sys/syslog.h>
  59 #include <sys/ucred.h>
  60
  61 #include <sys/md5.h>
  62 #include <crypto/siphash/siphash.h>
  63
  64 #include <vm/uma.h>
  65
  66 #include <net/if.h>
  67 #include <net/if_var.h>
  68 #include <net/route.h>
  69 #include <net/vnet.h>
  70
  71 #include <netinet/in.h>
  72 #include <netinet/in_kdtrace.h>
  73 #include <netinet/in_systm.h>
  74 #include <netinet/ip.h>
  75 #include <netinet/in_var.h>
  76 #include <netinet/in_pcb.h>
  77 #include <netinet/ip_var.h>
  78 #include <netinet/ip_options.h>
  79 #ifdef INET6
  80 #include <netinet/ip6.h>
  81 #include <netinet/icmp6.h>
  82 #include <netinet6/nd6.h>
  83 #include <netinet6/ip6_var.h>
  84 #include <netinet6/in6_pcb.h>
  85 #endif
  86 #include <netinet/tcp.h>
  87 #include <netinet/tcp_fastopen.h>
  88 #include <netinet/tcp_fsm.h>
  89 #include <netinet/tcp_seq.h>
  90 #include <netinet/tcp_timer.h>
  91 #include <netinet/tcp_var.h>
  92 #include <netinet/tcp_syncache.h>
  93 #ifdef INET6
  94 #include <netinet6/tcp6_var.h>
  95 #endif
  96 #ifdef TCP_OFFLOAD
  97 #include <netinet/toecore.h>
  98 #endif
  99
 100 #include <netipsec/ipsec_support.h>
 101
 102 #include <machine/in_cksum.h>
 103
 104 #include <security/mac/mac_framework.h>
 105
 106 VNET_DEFINE_STATIC(int, tcp_syncookies) = 1;
 107 #define V_tcp_syncookies                VNET(tcp_syncookies)
 108 SYSCTL_INT(_net_inet_tcp, OID_AUTO, syncookies, CTLFLAG_VNET | CTLFLAG_RW,
 109     &VNET_NAME(tcp_syncookies), 0,
 110     "Use TCP SYN cookies if the syncache overflows");
 111
 112 VNET_DEFINE_STATIC(int, tcp_syncookiesonly) = 0;
 113 #define V_tcp_syncookiesonly            VNET(tcp_syncookiesonly)
 114 SYSCTL_INT(_net_inet_tcp, OID_AUTO, syncookies_only, CTLFLAG_VNET | CTLFLAG_RW,
 115     &VNET_NAME(tcp_syncookiesonly), 0,
 116     "Use only TCP SYN cookies");
 117
 118 VNET_DEFINE_STATIC(int, functions_inherit_listen_socket_stack) = 1;
 119 #define V_functions_inherit_listen_socket_stack \
 120     VNET(functions_inherit_listen_socket_stack)
 121 SYSCTL_INT(_net_inet_tcp, OID_AUTO, functions_inherit_listen_socket_stack,
 122     CTLFLAG_VNET | CTLFLAG_RW,
 123     &VNET_NAME(functions_inherit_listen_socket_stack), 0,
 124     "Inherit listen socket's stack");
 125
 126 #ifdef TCP_OFFLOAD
 127 #define ADDED_BY_TOE(sc) ((sc)->sc_tod != NULL)
 128 #endif
 129
 130 static void      syncache_drop(struct syncache *, struct syncache_head *);
 131 static void      syncache_free(struct syncache *);
 132 static void      syncache_insert(struct syncache *, struct syncache_head *);
 133 static int       syncache_respond(struct syncache *, const struct mbuf *, int);
 134 static struct    socket *syncache_socket(struct syncache *, struct socket *,
 135                     struct mbuf *m);
 136 static void      syncache_timeout(struct syncache *sc, struct syncache_head *sch,
 137                     int docallout);
 138 static void      syncache_timer(void *);
 139
 140 static uint32_t  syncookie_mac(struct in_conninfo *, tcp_seq, uint8_t,
 141                     uint8_t *, uintptr_t);
 142 static tcp_seq   syncookie_generate(struct syncache_head *, struct syncache *);
 143 static struct syncache
 144                 *syncookie_lookup(struct in_conninfo *, struct syncache_head *,
 145                     struct syncache *, struct tcphdr *, struct tcpopt *,
 146                     struct socket *);
 147 static void     syncache_pause(struct in_conninfo *);
 148 static void     syncache_unpause(void *);
 149 static void      syncookie_reseed(void *);
 150 #ifdef INVARIANTS
 151 static int       syncookie_cmp(struct in_conninfo *inc, struct syncache_head *sch,
 152                     struct syncache *sc, struct tcphdr *th, struct tcpopt *to,
 153                     struct socket *lso);
 154 #endif
 155
 156 /*
 157  * Transmit the SYN,ACK fewer times than TCP_MAXRXTSHIFT specifies.
 158  * 3 retransmits corresponds to a timeout with default values of
 159  * tcp_rexmit_initial * (             1 +
 160  *                       tcp_backoff[1] +
 161  *                       tcp_backoff[2] +
 162  *                       tcp_backoff[3]) + 3 * tcp_rexmit_slop,
 163  * 1000 ms * (1 + 2 + 4 + 8) +  3 * 200 ms = 15600 ms,
 164  * the odds are that the user has given up attempting to connect by then.
 165  */
 166 #define SYNCACHE_MAXREXMTS              3
 167
 168 /* Arbitrary values */
 169 #define TCP_SYNCACHE_HASHSIZE           512
 170 #define TCP_SYNCACHE_BUCKETLIMIT        30
 171
 172 VNET_DEFINE_STATIC(struct tcp_syncache, tcp_syncache);
 173 #define V_tcp_syncache                  VNET(tcp_syncache)
 174
 175 static SYSCTL_NODE(_net_inet_tcp, OID_AUTO, syncache, CTLFLAG_RW, 0,
 176     "TCP SYN cache");
 177
 178 SYSCTL_UINT(_net_inet_tcp_syncache, OID_AUTO, bucketlimit, CTLFLAG_VNET | CTLFLAG_RDTUN,
 179     &VNET_NAME(tcp_syncache.bucket_limit), 0,
 180     "Per-bucket hash limit for syncache");
 181
 182 SYSCTL_UINT(_net_inet_tcp_syncache, OID_AUTO, cachelimit, CTLFLAG_VNET | CTLFLAG_RDTUN,
 183     &VNET_NAME(tcp_syncache.cache_limit), 0,
 184     "Overall entry limit for syncache");
 185
 186 SYSCTL_UMA_CUR(_net_inet_tcp_syncache, OID_AUTO, count, CTLFLAG_VNET,
 187     &VNET_NAME(tcp_syncache.zone), "Current number of entries in syncache");
 188
 189 SYSCTL_UINT(_net_inet_tcp_syncache, OID_AUTO, hashsize, CTLFLAG_VNET | CTLFLAG_RDTUN,
 190     &VNET_NAME(tcp_syncache.hashsize), 0,
 191     "Size of TCP syncache hashtable");
 192
 193 static int
 194 sysctl_net_inet_tcp_syncache_rexmtlimit_check(SYSCTL_HANDLER_ARGS)
 195 {
 196         int error;
 197         u_int new;
 198
 199         new = V_tcp_syncache.rexmt_limit;
 200         error = sysctl_handle_int(oidp, &new, 0, req);
 201         if ((error == 0) && (req->newptr != NULL)) {
 202                 if (new > TCP_MAXRXTSHIFT)
 203                         error = EINVAL;
 204                 else
 205                         V_tcp_syncache.rexmt_limit = new;
 206         }
 207         return (error);
 208 }
 209
 210 SYSCTL_PROC(_net_inet_tcp_syncache, OID_AUTO, rexmtlimit,
 211     CTLFLAG_VNET | CTLTYPE_UINT | CTLFLAG_RW,
 212     &VNET_NAME(tcp_syncache.rexmt_limit), 0,
 213     sysctl_net_inet_tcp_syncache_rexmtlimit_check, "UI",
 214     "Limit on SYN/ACK retransmissions");
 215
 216 VNET_DEFINE(int, tcp_sc_rst_sock_fail) = 1;
 217 SYSCTL_INT(_net_inet_tcp_syncache, OID_AUTO, rst_on_sock_fail,
 218     CTLFLAG_VNET | CTLFLAG_RW, &VNET_NAME(tcp_sc_rst_sock_fail), 0,
 219     "Send reset on socket allocation failure");
 220
 221 static MALLOC_DEFINE(M_SYNCACHE, "syncache", "TCP syncache");
 222
 223 #define SCH_LOCK(sch)           mtx_lock(&(sch)->sch_mtx)
 224 #define SCH_UNLOCK(sch)         mtx_unlock(&(sch)->sch_mtx)
 225 #define SCH_LOCK_ASSERT(sch)    mtx_assert(&(sch)->sch_mtx, MA_OWNED)
 226
 227 /*
 228  * Requires the syncache entry to be already removed from the bucket list.
 229  */
 230 static void
 231 syncache_free(struct syncache *sc)
 232 {
 233
 234         if (sc->sc_ipopts)
 235                 (void) m_free(sc->sc_ipopts);
 236         if (sc->sc_cred)
 237                 crfree(sc->sc_cred);
 238 #ifdef MAC
 239         mac_syncache_destroy(&sc->sc_label);
 240 #endif
 241
 242         uma_zfree(V_tcp_syncache.zone, sc);
 243 }
 244
 245 void
 246 syncache_init(void)
 247 {
 248         int i;
 249
 250         V_tcp_syncache.hashsize = TCP_SYNCACHE_HASHSIZE;
 251         V_tcp_syncache.bucket_limit = TCP_SYNCACHE_BUCKETLIMIT;
 252         V_tcp_syncache.rexmt_limit = SYNCACHE_MAXREXMTS;
 253         V_tcp_syncache.hash_secret = arc4random();
 254
 255         TUNABLE_INT_FETCH("net.inet.tcp.syncache.hashsize",
 256             &V_tcp_syncache.hashsize);
 257         TUNABLE_INT_FETCH("net.inet.tcp.syncache.bucketlimit",
 258             &V_tcp_syncache.bucket_limit);
 259         if (!powerof2(V_tcp_syncache.hashsize) ||
 260             V_tcp_syncache.hashsize == 0) {
 261                 printf("WARNING: syncache hash size is not a power of 2.\n");
 262                 V_tcp_syncache.hashsize = TCP_SYNCACHE_HASHSIZE;
 263         }
 264         V_tcp_syncache.hashmask = V_tcp_syncache.hashsize - 1;
 265
 266         /* Set limits. */
 267         V_tcp_syncache.cache_limit =
 268             V_tcp_syncache.hashsize * V_tcp_syncache.bucket_limit;
 269         TUNABLE_INT_FETCH("net.inet.tcp.syncache.cachelimit",
 270             &V_tcp_syncache.cache_limit);
 271
 272         /* Allocate the hash table. */
 273         V_tcp_syncache.hashbase = malloc(V_tcp_syncache.hashsize *
 274             sizeof(struct syncache_head), M_SYNCACHE, M_WAITOK | M_ZERO);
 275
 276 #ifdef VIMAGE
 277         V_tcp_syncache.vnet = curvnet;
 278 #endif
 279
 280         /* Initialize the hash buckets. */
 281         for (i = 0; i < V_tcp_syncache.hashsize; i++) {
 282                 TAILQ_INIT(&V_tcp_syncache.hashbase[i].sch_bucket);
 283                 mtx_init(&V_tcp_syncache.hashbase[i].sch_mtx, "tcp_sc_head",
 284                          NULL, MTX_DEF);
 285                 callout_init_mtx(&V_tcp_syncache.hashbase[i].sch_timer,
 286                          &V_tcp_syncache.hashbase[i].sch_mtx, 0);
 287                 V_tcp_syncache.hashbase[i].sch_length = 0;
 288                 V_tcp_syncache.hashbase[i].sch_sc = &V_tcp_syncache;
 289                 V_tcp_syncache.hashbase[i].sch_last_overflow =
 290                     -(SYNCOOKIE_LIFETIME + 1);
 291         }
 292
 293         /* Create the syncache entry zone. */
 294         V_tcp_syncache.zone = uma_zcreate("syncache", sizeof(struct syncache),
 295             NULL, NULL, NULL, NULL, UMA_ALIGN_PTR, 0);
 296         V_tcp_syncache.cache_limit = uma_zone_set_max(V_tcp_syncache.zone,
 297             V_tcp_syncache.cache_limit);
 298
 299         /* Start the SYN cookie reseeder callout. */
 300         callout_init(&V_tcp_syncache.secret.reseed, 1);
 301         arc4rand(V_tcp_syncache.secret.key[0], SYNCOOKIE_SECRET_SIZE, 0);
 302         arc4rand(V_tcp_syncache.secret.key[1], SYNCOOKIE_SECRET_SIZE, 0);
 303         callout_reset(&V_tcp_syncache.secret.reseed, SYNCOOKIE_LIFETIME * hz,
 304             syncookie_reseed, &V_tcp_syncache);
 305
 306         /* Initialize the pause machinery. */
 307         mtx_init(&V_tcp_syncache.pause_mtx, "tcp_sc_pause", NULL, MTX_DEF);
 308         callout_init_mtx(&V_tcp_syncache.pause_co, &V_tcp_syncache.pause_mtx,
 309             0);
 310         V_tcp_syncache.pause_until = time_uptime - TCP_SYNCACHE_PAUSE_TIME;
 311         V_tcp_syncache.pause_backoff = 0;
 312         V_tcp_syncache.paused = false;
 313 }
 314
 315 #ifdef VIMAGE
 316 void
 317 syncache_destroy(void)
 318 {
 319         struct syncache_head *sch;
 320         struct syncache *sc, *nsc;
 321         int i;
 322
 323         /*
 324          * Stop the re-seed timer before freeing resources.  No need to
 325          * possibly schedule it another time.
 326          */
 327         callout_drain(&V_tcp_syncache.secret.reseed);
 328
 329         /* Stop the SYN cache pause callout. */
 330         mtx_lock(&V_tcp_syncache.pause_mtx);
 331         if (callout_stop(&V_tcp_syncache.pause_co) == 0) {
 332                 mtx_unlock(&V_tcp_syncache.pause_mtx);
 333                 callout_drain(&V_tcp_syncache.pause_co);
 334         } else
 335                 mtx_unlock(&V_tcp_syncache.pause_mtx);
 336
 337         /* Cleanup hash buckets: stop timers, free entries, destroy locks. */
 338         for (i = 0; i < V_tcp_syncache.hashsize; i++) {
 339
 340                 sch = &V_tcp_syncache.hashbase[i];
 341                 callout_drain(&sch->sch_timer);
 342
 343                 SCH_LOCK(sch);
 344                 TAILQ_FOREACH_SAFE(sc, &sch->sch_bucket, sc_hash, nsc)
 345                         syncache_drop(sc, sch);
 346                 SCH_UNLOCK(sch);
 347                 KASSERT(TAILQ_EMPTY(&sch->sch_bucket),
 348                     ("%s: sch->sch_bucket not empty", __func__));
 349                 KASSERT(sch->sch_length == 0, ("%s: sch->sch_length %d not 0",
 350                     __func__, sch->sch_length));
 351                 mtx_destroy(&sch->sch_mtx);
 352         }
 353
 354         KASSERT(uma_zone_get_cur(V_tcp_syncache.zone) == 0,
 355             ("%s: cache_count not 0", __func__));
 356
 357         /* Free the allocated global resources. */
 358         uma_zdestroy(V_tcp_syncache.zone);
 359         free(V_tcp_syncache.hashbase, M_SYNCACHE);
 360         mtx_destroy(&V_tcp_syncache.pause_mtx);
 361 }
 362 #endif
 363
 364 /*
 365  * Inserts a syncache entry into the specified bucket row.
 366  * Locks and unlocks the syncache_head autonomously.
 367  */
 368 static void
 369 syncache_insert(struct syncache *sc, struct syncache_head *sch)
 370 {
 371         struct syncache *sc2;
 372
 373         SCH_LOCK(sch);
 374
 375         /*
 376          * Make sure that we don't overflow the per-bucket limit.
 377          * If the bucket is full, toss the oldest element.
 378          */
 379         if (sch->sch_length >= V_tcp_syncache.bucket_limit) {
 380                 KASSERT(!TAILQ_EMPTY(&sch->sch_bucket),
 381                         ("sch->sch_length incorrect"));
 382                 syncache_pause(&sc->sc_inc);
 383                 sc2 = TAILQ_LAST(&sch->sch_bucket, sch_head);
 384                 sch->sch_last_overflow = time_uptime;
 385                 syncache_drop(sc2, sch);
 386         }
 387
 388         /* Put it into the bucket. */
 389         TAILQ_INSERT_HEAD(&sch->sch_bucket, sc, sc_hash);
 390         sch->sch_length++;
 391
 392 #ifdef TCP_OFFLOAD
 393         if (ADDED_BY_TOE(sc)) {
 394                 struct toedev *tod = sc->sc_tod;
 395
 396                 tod->tod_syncache_added(tod, sc->sc_todctx);
 397         }
 398 #endif
 399
 400         /* Reinitialize the bucket row's timer. */
 401         if (sch->sch_length == 1)
 402                 sch->sch_nextc = ticks + INT_MAX;
 403         syncache_timeout(sc, sch, 1);
 404
 405         SCH_UNLOCK(sch);
 406
 407         TCPSTATES_INC(TCPS_SYN_RECEIVED);
 408         TCPSTAT_INC(tcps_sc_added);
 409 }
 410
 411 /*
 412  * Remove and free entry from syncache bucket row.
 413  * Expects locked syncache head.
 414  */
 415 static void
 416 syncache_drop(struct syncache *sc, struct syncache_head *sch)
 417 {
 418
 419         SCH_LOCK_ASSERT(sch);
 420
 421         TCPSTATES_DEC(TCPS_SYN_RECEIVED);
 422         TAILQ_REMOVE(&sch->sch_bucket, sc, sc_hash);
 423         sch->sch_length--;
 424
 425 #ifdef TCP_OFFLOAD
 426         if (ADDED_BY_TOE(sc)) {
 427                 struct toedev *tod = sc->sc_tod;
 428
 429                 tod->tod_syncache_removed(tod, sc->sc_todctx);
 430         }
 431 #endif
 432
 433         syncache_free(sc);
 434 }
 435
 436 /*
 437  * Engage/reengage time on bucket row.
 438  */
 439 static void
 440 syncache_timeout(struct syncache *sc, struct syncache_head *sch, int docallout)
 441 {
 442         int rexmt;
 443
 444         if (sc->sc_rxmits == 0)
 445                 rexmt = tcp_rexmit_initial;
 446         else
 447                 TCPT_RANGESET(rexmt,
 448                     tcp_rexmit_initial * tcp_backoff[sc->sc_rxmits],
 449                     tcp_rexmit_min, TCPTV_REXMTMAX);
 450         sc->sc_rxttime = ticks + rexmt;
 451         sc->sc_rxmits++;
 452         if (TSTMP_LT(sc->sc_rxttime, sch->sch_nextc)) {
 453                 sch->sch_nextc = sc->sc_rxttime;
 454                 if (docallout)
 455                         callout_reset(&sch->sch_timer, sch->sch_nextc - ticks,
 456                             syncache_timer, (void *)sch);
 457         }
 458 }
 459
 460 /*
 461  * Walk the timer queues, looking for SYN,ACKs that need to be retransmitted.
 462  * If we have retransmitted an entry the maximum number of times, expire it.
 463  * One separate timer for each bucket row.
 464  */
 465 static void
 466 syncache_timer(void *xsch)
 467 {
 468         struct syncache_head *sch = (struct syncache_head *)xsch;
 469         struct syncache *sc, *nsc;
 470         struct epoch_tracker et;
 471         int tick = ticks;
 472         char *s;
 473         bool paused;
 474
 475         CURVNET_SET(sch->sch_sc->vnet);
 476
 477         /* NB: syncache_head has already been locked by the callout. */
 478         SCH_LOCK_ASSERT(sch);
 479
 480         /*
 481          * In the following cycle we may remove some entries and/or
 482          * advance some timeouts, so re-initialize the bucket timer.
 483          */
 484         sch->sch_nextc = tick + INT_MAX;
 485
 486         /*
 487          * If we have paused processing, unconditionally remove
 488          * all syncache entries.
 489          */
 490         mtx_lock(&V_tcp_syncache.pause_mtx);
 491         paused = V_tcp_syncache.paused;
 492         mtx_unlock(&V_tcp_syncache.pause_mtx);
 493
 494         TAILQ_FOREACH_SAFE(sc, &sch->sch_bucket, sc_hash, nsc) {
 495                 if (paused) {
 496                         syncache_drop(sc, sch);
 497                         continue;
 498                 }
 499                 /*
 500                  * We do not check if the listen socket still exists
 501                  * and accept the case where the listen socket may be
 502                  * gone by the time we resend the SYN/ACK.  We do
 503                  * not expect this to happens often. If it does,
 504                  * then the RST will be sent by the time the remote
 505                  * host does the SYN/ACK->ACK.
 506                  */
 507                 if (TSTMP_GT(sc->sc_rxttime, tick)) {
 508                         if (TSTMP_LT(sc->sc_rxttime, sch->sch_nextc))
 509                                 sch->sch_nextc = sc->sc_rxttime;
 510                         continue;
 511                 }
 512                 if (sc->sc_rxmits > V_tcp_syncache.rexmt_limit) {
 513                         if ((s = tcp_log_addrs(&sc->sc_inc, NULL, NULL, NULL))) {
 514                                 log(LOG_DEBUG, "%s; %s: Retransmits exhausted, "
 515                                     "giving up and removing syncache entry\n",
 516                                     s, __func__);
 517                                 free(s, M_TCPLOG);
 518                         }
 519                         syncache_drop(sc, sch);
 520                         TCPSTAT_INC(tcps_sc_stale);
 521                         continue;
 522                 }
 523                 if ((s = tcp_log_addrs(&sc->sc_inc, NULL, NULL, NULL))) {
 524                         log(LOG_DEBUG, "%s; %s: Response timeout, "
 525                             "retransmitting (%u) SYN|ACK\n",
 526                             s, __func__, sc->sc_rxmits);
 527                         free(s, M_TCPLOG);
 528                 }
 529
 530                 NET_EPOCH_ENTER(et);
 531                 syncache_respond(sc, NULL, TH_SYN|TH_ACK);
 532                 NET_EPOCH_EXIT(et);
 533                 TCPSTAT_INC(tcps_sc_retransmitted);
 534                 syncache_timeout(sc, sch, 0);
 535         }
 536         if (!TAILQ_EMPTY(&(sch)->sch_bucket))
 537                 callout_reset(&(sch)->sch_timer, (sch)->sch_nextc - tick,
 538                         syncache_timer, (void *)(sch));
 539         CURVNET_RESTORE();
 540 }
 541
 542 /*
 543  * Returns true if the system is only using cookies at the moment.
 544  * This could be due to a sysadmin decision to only use cookies, or it
 545  * could be due to the system detecting an attack.
 546  */
 547 static inline bool
 548 syncache_cookiesonly(void)
 549 {
 550
 551         return (V_tcp_syncookies && (V_tcp_syncache.paused ||
 552             V_tcp_syncookiesonly));
 553 }
 554
 555 /*
 556  * Find the hash bucket for the given connection.
 557  */
 558 static struct syncache_head *
 559 syncache_hashbucket(struct in_conninfo *inc)
 560 {
 561         uint32_t hash;
 562
 563         /*
 564          * The hash is built on foreign port + local port + foreign address.
 565          * We rely on the fact that struct in_conninfo starts with 16 bits
 566          * of foreign port, then 16 bits of local port then followed by 128
 567          * bits of foreign address.  In case of IPv4 address, the first 3
 568          * 32-bit words of the address always are zeroes.
 569          */
 570         hash = jenkins_hash32((uint32_t *)&inc->inc_ie, 5,
 571             V_tcp_syncache.hash_secret) & V_tcp_syncache.hashmask;
 572
 573         return (&V_tcp_syncache.hashbase[hash]);
 574 }
 575
 576 /*
 577  * Find an entry in the syncache.
 578  * Returns always with locked syncache_head plus a matching entry or NULL.
 579  */
 580 static struct syncache *
 581 syncache_lookup(struct in_conninfo *inc, struct syncache_head **schp)
 582 {
 583         struct syncache *sc;
 584         struct syncache_head *sch;
 585
 586         *schp = sch = syncache_hashbucket(inc);
 587         SCH_LOCK(sch);
 588
 589         /* Circle through bucket row to find matching entry. */
 590         TAILQ_FOREACH(sc, &sch->sch_bucket, sc_hash)
 591                 if (bcmp(&inc->inc_ie, &sc->sc_inc.inc_ie,
 592                     sizeof(struct in_endpoints)) == 0)
 593                         break;
 594
 595         return (sc);    /* Always returns with locked sch. */
 596 }
 597
 598 /*
 599  * This function is called when we get a RST for a
 600  * non-existent connection, so that we can see if the
 601  * connection is in the syn cache.  If it is, zap it.
 602  * If required send a challenge ACK.
 603  */
 604 void
 605 syncache_chkrst(struct in_conninfo *inc, struct tcphdr *th, struct mbuf *m)
 606 {
 607         struct syncache *sc;
 608         struct syncache_head *sch;
 609         char *s = NULL;
 610
 611         if (syncache_cookiesonly())
 612                 return;
 613         sc = syncache_lookup(inc, &sch);        /* returns locked sch */
 614         SCH_LOCK_ASSERT(sch);
 615
 616         /*
 617          * Any RST to our SYN|ACK must not carry ACK, SYN or FIN flags.
 618          * See RFC 793 page 65, section SEGMENT ARRIVES.
 619          */
 620         if (th->th_flags & (TH_ACK|TH_SYN|TH_FIN)) {
 621                 if ((s = tcp_log_addrs(inc, th, NULL, NULL)))
 622                         log(LOG_DEBUG, "%s; %s: Spurious RST with ACK, SYN or "
 623                             "FIN flag set, segment ignored\n", s, __func__);
 624                 TCPSTAT_INC(tcps_badrst);
 625                 goto done;
 626         }
 627
 628         /*
 629          * No corresponding connection was found in syncache.
 630          * If syncookies are enabled and possibly exclusively
 631          * used, or we are under memory pressure, a valid RST
 632          * may not find a syncache entry.  In that case we're
 633          * done and no SYN|ACK retransmissions will happen.
 634          * Otherwise the RST was misdirected or spoofed.
 635          */
 636         if (sc == NULL) {
 637                 if ((s = tcp_log_addrs(inc, th, NULL, NULL)))
 638                         log(LOG_DEBUG, "%s; %s: Spurious RST without matching "
 639                             "syncache entry (possibly syncookie only), "
 640                             "segment ignored\n", s, __func__);
 641                 TCPSTAT_INC(tcps_badrst);
 642                 goto done;
 643         }
 644
 645         /*
 646          * If the RST bit is set, check the sequence number to see
 647          * if this is a valid reset segment.
 648          *
 649          * RFC 793 page 37:
 650          *   In all states except SYN-SENT, all reset (RST) segments
 651          *   are validated by checking their SEQ-fields.  A reset is
 652          *   valid if its sequence number is in the window.
 653          *
 654          * RFC 793 page 69:
 655          *   There are four cases for the acceptability test for an incoming
 656          *   segment:
 657          *
 658          * Segment Receive  Test
 659          * Length  Window
 660          * ------- -------  -------------------------------------------
 661          *    0       0     SEG.SEQ = RCV.NXT
 662          *    0      >0     RCV.NXT =< SEG.SEQ < RCV.NXT+RCV.WND
 663          *   >0       0     not acceptable
 664          *   >0      >0     RCV.NXT =< SEG.SEQ < RCV.NXT+RCV.WND
 665          *               or RCV.NXT =< SEG.SEQ+SEG.LEN-1 < RCV.NXT+RCV.WND
 666          *
 667          * Note that when receiving a SYN segment in the LISTEN state,
 668          * IRS is set to SEG.SEQ and RCV.NXT is set to SEG.SEQ+1, as
 669          * described in RFC 793, page 66.
 670          */
 671         if ((SEQ_GEQ(th->th_seq, sc->sc_irs + 1) &&
 672             SEQ_LT(th->th_seq, sc->sc_irs + 1 + sc->sc_wnd)) ||
 673             (sc->sc_wnd == 0 && th->th_seq == sc->sc_irs + 1)) {
 674                 if (V_tcp_insecure_rst ||
 675                     th->th_seq == sc->sc_irs + 1) {
 676                         syncache_drop(sc, sch);
 677                         if ((s = tcp_log_addrs(inc, th, NULL, NULL)))
 678                                 log(LOG_DEBUG,
 679                                     "%s; %s: Our SYN|ACK was rejected, "
 680                                     "connection attempt aborted by remote "
 681                                     "endpoint\n",
 682                                     s, __func__);
 683                         TCPSTAT_INC(tcps_sc_reset);
 684                 } else {
 685                         TCPSTAT_INC(tcps_badrst);
 686                         /* Send challenge ACK. */
 687                         if ((s = tcp_log_addrs(inc, th, NULL, NULL)))
 688                                 log(LOG_DEBUG, "%s; %s: RST with invalid "
 689                                     " SEQ %u != NXT %u (+WND %u), "
 690                                     "sending challenge ACK\n",
 691                                     s, __func__,
 692                                     th->th_seq, sc->sc_irs + 1, sc->sc_wnd);
 693                         syncache_respond(sc, m, TH_ACK);
 694                 }
 695         } else {
 696                 if ((s = tcp_log_addrs(inc, th, NULL, NULL)))
 697                         log(LOG_DEBUG, "%s; %s: RST with invalid SEQ %u != "
 698                             "NXT %u (+WND %u), segment ignored\n",
 699                             s, __func__,
 700                             th->th_seq, sc->sc_irs + 1, sc->sc_wnd);
 701                 TCPSTAT_INC(tcps_badrst);
 702         }
 703
 704 done:
 705         if (s != NULL)
 706                 free(s, M_TCPLOG);
 707         SCH_UNLOCK(sch);
 708 }
 709
 710 void
 711 syncache_badack(struct in_conninfo *inc)
 712 {
 713         struct syncache *sc;
 714         struct syncache_head *sch;
 715
 716         if (syncache_cookiesonly())
 717                 return;
 718         sc = syncache_lookup(inc, &sch);        /* returns locked sch */
 719         SCH_LOCK_ASSERT(sch);
 720         if (sc != NULL) {
 721                 syncache_drop(sc, sch);
 722                 TCPSTAT_INC(tcps_sc_badack);
 723         }
 724         SCH_UNLOCK(sch);
 725 }
 726
 727 void
 728 syncache_unreach(struct in_conninfo *inc, tcp_seq th_seq)
 729 {
 730         struct syncache *sc;
 731         struct syncache_head *sch;
 732
 733         if (syncache_cookiesonly())
 734                 return;
 735         sc = syncache_lookup(inc, &sch);        /* returns locked sch */
 736         SCH_LOCK_ASSERT(sch);
 737         if (sc == NULL)
 738                 goto done;
 739
 740         /* If the sequence number != sc_iss, then it's a bogus ICMP msg */
 741         if (ntohl(th_seq) != sc->sc_iss)
 742                 goto done;
 743
 744         /*
 745          * If we've rertransmitted 3 times and this is our second error,
 746          * we remove the entry.  Otherwise, we allow it to continue on.
 747          * This prevents us from incorrectly nuking an entry during a
 748          * spurious network outage.
 749          *
 750          * See tcp_notify().
 751          */
 752         if ((sc->sc_flags & SCF_UNREACH) == 0 || sc->sc_rxmits < 3 + 1) {
 753                 sc->sc_flags |= SCF_UNREACH;
 754                 goto done;
 755         }
 756         syncache_drop(sc, sch);
 757         TCPSTAT_INC(tcps_sc_unreach);
 758 done:
 759         SCH_UNLOCK(sch);
 760 }
 761
 762 /*
 763  * Build a new TCP socket structure from a syncache entry.
 764  *
 765  * On success return the newly created socket with its underlying inp locked.
 766  */
 767 static struct socket *
 768 syncache_socket(struct syncache *sc, struct socket *lso, struct mbuf *m)
 769 {
 770         struct tcp_function_block *blk;
 771         struct inpcb *inp = NULL;
 772         struct socket *so;
 773         struct tcpcb *tp;
 774         int error;
 775         char *s;
 776
 777         NET_EPOCH_ASSERT();
 778
 779         /*
 780          * Ok, create the full blown connection, and set things up
 781          * as they would have been set up if we had created the
 782          * connection when the SYN arrived.  If we can't create
 783          * the connection, abort it.
 784          */
 785         so = sonewconn(lso, 0);
 786         if (so == NULL) {
 787                 /*
 788                  * Drop the connection; we will either send a RST or
 789                  * have the peer retransmit its SYN again after its
 790                  * RTO and try again.
 791                  */
 792                 TCPSTAT_INC(tcps_listendrop);
 793                 if ((s = tcp_log_addrs(&sc->sc_inc, NULL, NULL, NULL))) {
 794                         log(LOG_DEBUG, "%s; %s: Socket create failed "
 795                             "due to limits or memory shortage\n",
 796                             s, __func__);
 797                         free(s, M_TCPLOG);
 798                 }
 799                 goto abort2;
 800         }
 801 #ifdef MAC
 802         mac_socketpeer_set_from_mbuf(m, so);
 803 #endif
 804
 805         inp = sotoinpcb(so);
 806         inp->inp_inc.inc_fibnum = so->so_fibnum;
 807         INP_WLOCK(inp);
 808         /*
 809          * Exclusive pcbinfo lock is not required in syncache socket case even
 810          * if two inpcb locks can be acquired simultaneously:
 811          *  - the inpcb in LISTEN state,
 812          *  - the newly created inp.
 813          *
 814          * In this case, an inp cannot be at same time in LISTEN state and
 815          * just created by an accept() call.
 816          */
 817         INP_HASH_WLOCK(&V_tcbinfo);
 818
 819         /* Insert new socket into PCB hash list. */
 820         inp->inp_inc.inc_flags = sc->sc_inc.inc_flags;
 821 #ifdef INET6
 822         if (sc->sc_inc.inc_flags & INC_ISIPV6) {
 823                 inp->inp_vflag &= ~INP_IPV4;
 824                 inp->inp_vflag |= INP_IPV6;
 825                 inp->in6p_laddr = sc->sc_inc.inc6_laddr;
 826         } else {
 827                 inp->inp_vflag &= ~INP_IPV6;
 828                 inp->inp_vflag |= INP_IPV4;
 829 #endif
 830                 inp->inp_laddr = sc->sc_inc.inc_laddr;
 831 #ifdef INET6
 832         }
 833 #endif
 834
 835         /*
 836          * If there's an mbuf and it has a flowid, then let's initialise the
 837          * inp with that particular flowid.
 838          */
 839         if (m != NULL && M_HASHTYPE_GET(m) != M_HASHTYPE_NONE) {
 840                 inp->inp_flowid = m->m_pkthdr.flowid;
 841                 inp->inp_flowtype = M_HASHTYPE_GET(m);
 842 #ifdef NUMA
 843                 inp->inp_numa_domain = m->m_pkthdr.numa_domain;
 844 #endif
 845         }
 846
 847         inp->inp_lport = sc->sc_inc.inc_lport;
 848 #ifdef INET6
 849         if (inp->inp_vflag & INP_IPV6PROTO) {
 850                 struct inpcb *oinp = sotoinpcb(lso);
 851
 852                 /*
 853                  * Inherit socket options from the listening socket.
 854                  * Note that in6p_inputopts are not (and should not be)
 855                  * copied, since it stores previously received options and is
 856                  * used to detect if each new option is different than the
 857                  * previous one and hence should be passed to a user.
 858                  * If we copied in6p_inputopts, a user would not be able to
 859                  * receive options just after calling the accept system call.
 860                  */
 861                 inp->inp_flags |= oinp->inp_flags & INP_CONTROLOPTS;
 862                 if (oinp->in6p_outputopts)
 863                         inp->in6p_outputopts =
 864                             ip6_copypktopts(oinp->in6p_outputopts, M_NOWAIT);
 865         }
 866
 867         if (sc->sc_inc.inc_flags & INC_ISIPV6) {
 868                 struct in6_addr laddr6;
 869                 struct sockaddr_in6 sin6;
 870
 871                 sin6.sin6_family = AF_INET6;
 872                 sin6.sin6_len = sizeof(sin6);
 873                 sin6.sin6_addr = sc->sc_inc.inc6_faddr;
 874                 sin6.sin6_port = sc->sc_inc.inc_fport;
 875                 sin6.sin6_flowinfo = sin6.sin6_scope_id = 0;
 876                 laddr6 = inp->in6p_laddr;
 877                 if (IN6_IS_ADDR_UNSPECIFIED(&inp->in6p_laddr))
 878                         inp->in6p_laddr = sc->sc_inc.inc6_laddr;
 879                 if ((error = in6_pcbconnect_mbuf(inp, (struct sockaddr *)&sin6,
 880                     thread0.td_ucred, m, false)) != 0) {
 881                         inp->in6p_laddr = laddr6;
 882                         if ((s = tcp_log_addrs(&sc->sc_inc, NULL, NULL, NULL))) {
 883                                 log(LOG_DEBUG, "%s; %s: in6_pcbconnect failed "
 884                                     "with error %i\n",
 885                                     s, __func__, error);
 886                                 free(s, M_TCPLOG);
 887                         }
 888                         INP_HASH_WUNLOCK(&V_tcbinfo);
 889                         goto abort;
 890                 }
 891                 /* Override flowlabel from in6_pcbconnect. */
 892                 inp->inp_flow &= ~IPV6_FLOWLABEL_MASK;
 893                 inp->inp_flow |= sc->sc_flowlabel;
 894         }
 895 #endif /* INET6 */
 896 #if defined(INET) && defined(INET6)
 897         else
 898 #endif
 899 #ifdef INET
 900         {
 901                 struct in_addr laddr;
 902                 struct sockaddr_in sin;
 903
 904                 inp->inp_options = (m) ? ip_srcroute(m) : NULL;
 905
 906                 if (inp->inp_options == NULL) {
 907                         inp->inp_options = sc->sc_ipopts;
 908                         sc->sc_ipopts = NULL;
 909                 }
 910
 911                 sin.sin_family = AF_INET;
 912                 sin.sin_len = sizeof(sin);
 913                 sin.sin_addr = sc->sc_inc.inc_faddr;
 914                 sin.sin_port = sc->sc_inc.inc_fport;
 915                 bzero((caddr_t)sin.sin_zero, sizeof(sin.sin_zero));
 916                 laddr = inp->inp_laddr;
 917                 if (inp->inp_laddr.s_addr == INADDR_ANY)
 918                         inp->inp_laddr = sc->sc_inc.inc_laddr;
 919                 if ((error = in_pcbconnect_mbuf(inp, (struct sockaddr *)&sin,
 920                     thread0.td_ucred, m, false)) != 0) {
 921                         inp->inp_laddr = laddr;
 922                         if ((s = tcp_log_addrs(&sc->sc_inc, NULL, NULL, NULL))) {
 923                                 log(LOG_DEBUG, "%s; %s: in_pcbconnect failed "
 924                                     "with error %i\n",
 925                                     s, __func__, error);
 926                                 free(s, M_TCPLOG);
 927                         }
 928                         INP_HASH_WUNLOCK(&V_tcbinfo);
 929                         goto abort;
 930                 }
 931         }
 932 #endif /* INET */
 933 #if defined(IPSEC) || defined(IPSEC_SUPPORT)
 934         /* Copy old policy into new socket's. */
 935         if (ipsec_copy_pcbpolicy(sotoinpcb(lso), inp) != 0)
 936                 printf("syncache_socket: could not copy policy\n");
 937 #endif
 938         INP_HASH_WUNLOCK(&V_tcbinfo);
 939         tp = intotcpcb(inp);
 940         tcp_state_change(tp, TCPS_SYN_RECEIVED);
 941         tp->iss = sc->sc_iss;
 942         tp->irs = sc->sc_irs;
 943         tcp_rcvseqinit(tp);
 944         tcp_sendseqinit(tp);
 945         blk = sototcpcb(lso)->t_fb;
 946         if (V_functions_inherit_listen_socket_stack && blk != tp->t_fb) {
 947                 /*
 948                  * Our parents t_fb was not the default,
 949                  * we need to release our ref on tp->t_fb and
 950                  * pickup one on the new entry.
 951                  */
 952                 struct tcp_function_block *rblk;
 953
 954                 rblk = find_and_ref_tcp_fb(blk);
 955                 KASSERT(rblk != NULL,
 956                     ("cannot find blk %p out of syncache?", blk));
 957                 if (tp->t_fb->tfb_tcp_fb_fini)
 958                         (*tp->t_fb->tfb_tcp_fb_fini)(tp, 0);
 959                 refcount_release(&tp->t_fb->tfb_refcnt);
 960                 tp->t_fb = rblk;
 961                 /*
 962                  * XXXrrs this is quite dangerous, it is possible
 963                  * for the new function to fail to init. We also
 964                  * are not asking if the handoff_is_ok though at
 965                  * the very start thats probalbly ok.
 966                  */
 967                 if (tp->t_fb->tfb_tcp_fb_init) {
 968                         (*tp->t_fb->tfb_tcp_fb_init)(tp);
 969                 }
 970         }
 971         tp->snd_wl1 = sc->sc_irs;
 972         tp->snd_max = tp->iss + 1;
 973         tp->snd_nxt = tp->iss + 1;
 974         tp->rcv_up = sc->sc_irs + 1;
 975         tp->rcv_wnd = sc->sc_wnd;
 976         tp->rcv_adv += tp->rcv_wnd;
 977         tp->last_ack_sent = tp->rcv_nxt;
 978
 979         tp->t_flags = sototcpcb(lso)->t_flags & (TF_NOPUSH|TF_NODELAY);
 980         if (sc->sc_flags & SCF_NOOPT)
 981                 tp->t_flags |= TF_NOOPT;
 982         else {
 983                 if (sc->sc_flags & SCF_WINSCALE) {
 984                         tp->t_flags |= TF_REQ_SCALE|TF_RCVD_SCALE;
 985                         tp->snd_scale = sc->sc_requested_s_scale;
 986                         tp->request_r_scale = sc->sc_requested_r_scale;
 987                 }
 988                 if (sc->sc_flags & SCF_TIMESTAMP) {
 989                         tp->t_flags |= TF_REQ_TSTMP|TF_RCVD_TSTMP;
 990                         tp->ts_recent = sc->sc_tsreflect;
 991                         tp->ts_recent_age = tcp_ts_getticks();
 992                         tp->ts_offset = sc->sc_tsoff;
 993                 }
 994 #if defined(IPSEC_SUPPORT) || defined(TCP_SIGNATURE)
 995                 if (sc->sc_flags & SCF_SIGNATURE)
 996                         tp->t_flags |= TF_SIGNATURE;
 997 #endif
 998                 if (sc->sc_flags & SCF_SACK)
 999                         tp->t_flags |= TF_SACK_PERMIT;
1000         }
1001
1002         if (sc->sc_flags & SCF_ECN)
1003                 tp->t_flags2 |= TF2_ECN_PERMIT;
1004
1005         /*
1006          * Set up MSS and get cached values from tcp_hostcache.
1007          * This might overwrite some of the defaults we just set.
1008          */
1009         tcp_mss(tp, sc->sc_peer_mss);
1010
1011         /*
1012          * If the SYN,ACK was retransmitted, indicate that CWND to be
1013          * limited to one segment in cc_conn_init().
1014          * NB: sc_rxmits counts all SYN,ACK transmits, not just retransmits.
1015          */
1016         if (sc->sc_rxmits > 1)
1017                 tp->snd_cwnd = 1;
1018
1019 #ifdef TCP_OFFLOAD
1020         /*
1021          * Allow a TOE driver to install its hooks.  Note that we hold the
1022          * pcbinfo lock too and that prevents tcp_usr_accept from accepting a
1023          * new connection before the TOE driver has done its thing.
1024          */
1025         if (ADDED_BY_TOE(sc)) {
1026                 struct toedev *tod = sc->sc_tod;
1027
1028                 tod->tod_offload_socket(tod, sc->sc_todctx, so);
1029         }
1030 #endif
1031         /*
1032          * Copy and activate timers.
1033          */
1034         tp->t_keepinit = sototcpcb(lso)->t_keepinit;
1035         tp->t_keepidle = sototcpcb(lso)->t_keepidle;
1036         tp->t_keepintvl = sototcpcb(lso)->t_keepintvl;
1037         tp->t_keepcnt = sototcpcb(lso)->t_keepcnt;
1038         tcp_timer_activate(tp, TT_KEEP, TP_KEEPINIT(tp));
1039
1040         TCPSTAT_INC(tcps_accepts);
1041         return (so);
1042
1043 abort:
1044         INP_WUNLOCK(inp);
1045 abort2:
1046         if (so != NULL)
1047                 soabort(so);
1048         return (NULL);
1049 }
1050
1051 /*
1052  * This function gets called when we receive an ACK for a
1053  * socket in the LISTEN state.  We look up the connection
1054  * in the syncache, and if its there, we pull it out of
1055  * the cache and turn it into a full-blown connection in
1056  * the SYN-RECEIVED state.
1057  *
1058  * On syncache_socket() success the newly created socket
1059  * has its underlying inp locked.
1060  */
1061 int
1062 syncache_expand(struct in_conninfo *inc, struct tcpopt *to, struct tcphdr *th,
1063     struct socket **lsop, struct mbuf *m)
1064 {
1065         struct syncache *sc;
1066         struct syncache_head *sch;
1067         struct syncache scs;
1068         char *s;
1069         bool locked;
1070
1071         NET_EPOCH_ASSERT();
1072         KASSERT((th->th_flags & (TH_RST|TH_ACK|TH_SYN)) == TH_ACK,
1073             ("%s: can handle only ACK", __func__));
1074
1075         if (syncache_cookiesonly()) {
1076                 sc = NULL;
1077                 sch = syncache_hashbucket(inc);
1078                 locked = false;
1079         } else {
1080                 sc = syncache_lookup(inc, &sch);        /* returns locked sch */
1081                 locked = true;
1082                 SCH_LOCK_ASSERT(sch);
1083         }
1084
1085 #ifdef INVARIANTS
1086         /*
1087          * Test code for syncookies comparing the syncache stored
1088          * values with the reconstructed values from the cookie.
1089          */
1090         if (sc != NULL)
1091                 syncookie_cmp(inc, sch, sc, th, to, *lsop);
1092 #endif
1093
1094         if (sc == NULL) {
1095                 /*
1096                  * There is no syncache entry, so see if this ACK is
1097                  * a returning syncookie.  To do this, first:
1098                  *  A. Check if syncookies are used in case of syncache
1099                  *     overflows
1100                  *  B. See if this socket has had a syncache entry dropped in
1101                  *     the recent past. We don't want to accept a bogus
1102                  *     syncookie if we've never received a SYN or accept it
1103                  *     twice.
1104                  *  C. check that the syncookie is valid.  If it is, then
1105                  *     cobble up a fake syncache entry, and return.
1106                  */
1107                 if (locked && !V_tcp_syncookies) {
1108                         SCH_UNLOCK(sch);
1109                         if ((s = tcp_log_addrs(inc, th, NULL, NULL)))
1110                                 log(LOG_DEBUG, "%s; %s: Spurious ACK, "
1111                                     "segment rejected (syncookies disabled)\n",
1112                                     s, __func__);
1113                         goto failed;
1114                 }
1115                 if (locked && !V_tcp_syncookiesonly &&
1116                     sch->sch_last_overflow < time_uptime - SYNCOOKIE_LIFETIME) {
1117                         SCH_UNLOCK(sch);
1118                         if ((s = tcp_log_addrs(inc, th, NULL, NULL)))
1119                                 log(LOG_DEBUG, "%s; %s: Spurious ACK, "
1120                                     "segment rejected (no syncache entry)\n",
1121                                     s, __func__);
1122                         goto failed;
1123                 }
1124                 bzero(&scs, sizeof(scs));
1125                 sc = syncookie_lookup(inc, sch, &scs, th, to, *lsop);
1126                 if (locked)
1127                         SCH_UNLOCK(sch);
1128                 if (sc == NULL) {
1129                         if ((s = tcp_log_addrs(inc, th, NULL, NULL)))
1130                                 log(LOG_DEBUG, "%s; %s: Segment failed "
1131                                     "SYNCOOKIE authentication, segment rejected "
1132                                     "(probably spoofed)\n", s, __func__);
1133                         goto failed;
1134                 }
1135 #if defined(IPSEC_SUPPORT) || defined(TCP_SIGNATURE)
1136                 /* If received ACK has MD5 signature, check it. */
1137                 if ((to->to_flags & TOF_SIGNATURE) != 0 &&
1138                     (!TCPMD5_ENABLED() ||
1139                     TCPMD5_INPUT(m, th, to->to_signature) != 0)) {
1140                         /* Drop the ACK. */
1141                         if ((s = tcp_log_addrs(inc, th, NULL, NULL))) {
1142                                 log(LOG_DEBUG, "%s; %s: Segment rejected, "
1143                                     "MD5 signature doesn't match.\n",
1144                                     s, __func__);
1145                                 free(s, M_TCPLOG);
1146                         }
1147                         TCPSTAT_INC(tcps_sig_err_sigopt);
1148                         return (-1); /* Do not send RST */
1149                 }
1150 #endif /* TCP_SIGNATURE */
1151         } else {
1152 #if defined(IPSEC_SUPPORT) || defined(TCP_SIGNATURE)
1153                 /*
1154                  * If listening socket requested TCP digests, check that
1155                  * received ACK has signature and it is correct.
1156                  * If not, drop the ACK and leave sc entry in th cache,
1157                  * because SYN was received with correct signature.
1158                  */
1159                 if (sc->sc_flags & SCF_SIGNATURE) {
1160                         if ((to->to_flags & TOF_SIGNATURE) == 0) {
1161                                 /* No signature */
1162                                 TCPSTAT_INC(tcps_sig_err_nosigopt);
1163                                 SCH_UNLOCK(sch);
1164                                 if ((s = tcp_log_addrs(inc, th, NULL, NULL))) {
1165                                         log(LOG_DEBUG, "%s; %s: Segment "
1166                                             "rejected, MD5 signature wasn't "
1167                                             "provided.\n", s, __func__);
1168                                         free(s, M_TCPLOG);
1169                                 }
1170                                 return (-1); /* Do not send RST */
1171                         }
1172                         if (!TCPMD5_ENABLED() ||
1173                             TCPMD5_INPUT(m, th, to->to_signature) != 0) {
1174                                 /* Doesn't match or no SA */
1175                                 SCH_UNLOCK(sch);
1176                                 if ((s = tcp_log_addrs(inc, th, NULL, NULL))) {
1177                                         log(LOG_DEBUG, "%s; %s: Segment "
1178                                             "rejected, MD5 signature doesn't "
1179                                             "match.\n", s, __func__);
1180                                         free(s, M_TCPLOG);
1181                                 }
1182                                 return (-1); /* Do not send RST */
1183                         }
1184                 }
1185 #endif /* TCP_SIGNATURE */
1186
1187                 /*
1188                  * RFC 7323 PAWS: If we have a timestamp on this segment and
1189                  * it's less than ts_recent, drop it.
1190                  * XXXMT: RFC 7323 also requires to send an ACK.
1191                  *        In tcp_input.c this is only done for TCP segments
1192                  *        with user data, so be consistent here and just drop
1193                  *        the segment.
1194                  */
1195                 if (sc->sc_flags & SCF_TIMESTAMP && to->to_flags & TOF_TS &&
1196                     TSTMP_LT(to->to_tsval, sc->sc_tsreflect)) {
1197                         SCH_UNLOCK(sch);
1198                         if ((s = tcp_log_addrs(inc, th, NULL, NULL))) {
1199                                 log(LOG_DEBUG,
1200                                     "%s; %s: SEG.TSval %u < TS.Recent %u, "
1201                                     "segment dropped\n", s, __func__,
1202                                     to->to_tsval, sc->sc_tsreflect);
1203                                 free(s, M_TCPLOG);
1204                         }
1205                         return (-1);  /* Do not send RST */
1206                 }
1207
1208                 /*
1209                  * Pull out the entry to unlock the bucket row.
1210                  *
1211                  * NOTE: We must decrease TCPS_SYN_RECEIVED count here, not
1212                  * tcp_state_change().  The tcpcb is not existent at this
1213                  * moment.  A new one will be allocated via syncache_socket->
1214                  * sonewconn->tcp_usr_attach in TCPS_CLOSED state, then
1215                  * syncache_socket() will change it to TCPS_SYN_RECEIVED.
1216                  */
1217                 TCPSTATES_DEC(TCPS_SYN_RECEIVED);
1218                 TAILQ_REMOVE(&sch->sch_bucket, sc, sc_hash);
1219                 sch->sch_length--;
1220 #ifdef TCP_OFFLOAD
1221                 if (ADDED_BY_TOE(sc)) {
1222                         struct toedev *tod = sc->sc_tod;
1223
1224                         tod->tod_syncache_removed(tod, sc->sc_todctx);
1225                 }
1226 #endif
1227                 SCH_UNLOCK(sch);
1228         }
1229
1230         /*
1231          * Segment validation:
1232          * ACK must match our initial sequence number + 1 (the SYN|ACK).
1233          */
1234         if (th->th_ack != sc->sc_iss + 1) {
1235                 if ((s = tcp_log_addrs(inc, th, NULL, NULL)))
1236                         log(LOG_DEBUG, "%s; %s: ACK %u != ISS+1 %u, segment "
1237                             "rejected\n", s, __func__, th->th_ack, sc->sc_iss);
1238                 goto failed;
1239         }
1240
1241         /*
1242          * The SEQ must fall in the window starting at the received
1243          * initial receive sequence number + 1 (the SYN).
1244          */
1245         if (SEQ_LEQ(th->th_seq, sc->sc_irs) ||
1246             SEQ_GT(th->th_seq, sc->sc_irs + sc->sc_wnd)) {
1247                 if ((s = tcp_log_addrs(inc, th, NULL, NULL)))
1248                         log(LOG_DEBUG, "%s; %s: SEQ %u != IRS+1 %u, segment "
1249                             "rejected\n", s, __func__, th->th_seq, sc->sc_irs);
1250                 goto failed;
1251         }
1252
1253         /*
1254          * If timestamps were not negotiated during SYN/ACK they
1255          * must not appear on any segment during this session.
1256          */
1257         if (!(sc->sc_flags & SCF_TIMESTAMP) && (to->to_flags & TOF_TS)) {
1258                 if ((s = tcp_log_addrs(inc, th, NULL, NULL)))
1259                         log(LOG_DEBUG, "%s; %s: Timestamp not expected, "
1260                             "segment rejected\n", s, __func__);
1261                 goto failed;
1262         }
1263
1264         /*
1265          * If timestamps were negotiated during SYN/ACK they should
1266          * appear on every segment during this session.
1267          * XXXAO: This is only informal as there have been unverified
1268          * reports of non-compliants stacks.
1269          */
1270         if ((sc->sc_flags & SCF_TIMESTAMP) && !(to->to_flags & TOF_TS)) {
1271                 if ((s = tcp_log_addrs(inc, th, NULL, NULL))) {
1272                         log(LOG_DEBUG, "%s; %s: Timestamp missing, "
1273                             "no action\n", s, __func__);
1274                         free(s, M_TCPLOG);
1275                         s = NULL;
1276                 }
1277         }
1278
1279         *lsop = syncache_socket(sc, *lsop, m);
1280
1281         if (*lsop == NULL)
1282                 TCPSTAT_INC(tcps_sc_aborted);
1283         else
1284                 TCPSTAT_INC(tcps_sc_completed);
1285
1286 /* how do we find the inp for the new socket? */
1287         if (sc != &scs)
1288                 syncache_free(sc);
1289         return (1);
1290 failed:
1291         if (sc != NULL && sc != &scs)
1292                 syncache_free(sc);
1293         if (s != NULL)
1294                 free(s, M_TCPLOG);
1295         *lsop = NULL;
1296         return (0);
1297 }
1298
1299 static void
1300 syncache_tfo_expand(struct syncache *sc, struct socket **lsop, struct mbuf *m,
1301     uint64_t response_cookie)
1302 {
1303         struct inpcb *inp;
1304         struct tcpcb *tp;
1305         unsigned int *pending_counter;
1306
1307         NET_EPOCH_ASSERT();
1308
1309         pending_counter = intotcpcb(sotoinpcb(*lsop))->t_tfo_pending;
1310         *lsop = syncache_socket(sc, *lsop, m);
1311         if (*lsop == NULL) {
1312                 TCPSTAT_INC(tcps_sc_aborted);
1313                 atomic_subtract_int(pending_counter, 1);
1314         } else {
1315                 soisconnected(*lsop);
1316                 inp = sotoinpcb(*lsop);
1317                 tp = intotcpcb(inp);
1318                 tp->t_flags |= TF_FASTOPEN;
1319                 tp->t_tfo_cookie.server = response_cookie;
1320                 tp->snd_max = tp->iss;
1321                 tp->snd_nxt = tp->iss;
1322                 tp->t_tfo_pending = pending_counter;
1323                 TCPSTAT_INC(tcps_sc_completed);
1324         }
1325 }
1326
1327 /*
1328  * Given a LISTEN socket and an inbound SYN request, add
1329  * this to the syn cache, and send back a segment:
1330  *      <SEQ=ISS><ACK=RCV_NXT><CTL=SYN,ACK>
1331  * to the source.
1332  *
1333  * IMPORTANT NOTE: We do _NOT_ ACK data that might accompany the SYN.
1334  * Doing so would require that we hold onto the data and deliver it
1335  * to the application.  However, if we are the target of a SYN-flood
1336  * DoS attack, an attacker could send data which would eventually
1337  * consume all available buffer space if it were ACKed.  By not ACKing
1338  * the data, we avoid this DoS scenario.
1339  *
1340  * The exception to the above is when a SYN with a valid TCP Fast Open (TFO)
1341  * cookie is processed and a new socket is created.  In this case, any data
1342  * accompanying the SYN will be queued to the socket by tcp_input() and will
1343  * be ACKed either when the application sends response data or the delayed
1344  * ACK timer expires, whichever comes first.
1345  */
1346 int
1347 syncache_add(struct in_conninfo *inc, struct tcpopt *to, struct tcphdr *th,
1348     struct inpcb *inp, struct socket **lsop, struct mbuf *m, void *tod,
1349     void *todctx, uint8_t iptos)
1350 {
1351         struct tcpcb *tp;
1352         struct socket *so;
1353         struct syncache *sc = NULL;
1354         struct syncache_head *sch;
1355         struct mbuf *ipopts = NULL;
1356         u_int ltflags;
1357         int win, ip_ttl, ip_tos;
1358         char *s;
1359         int rv = 0;
1360 #ifdef INET6
1361         int autoflowlabel = 0;
1362 #endif
1363 #ifdef MAC
1364         struct label *maclabel;
1365 #endif
1366         struct syncache scs;
1367         struct ucred *cred;
1368         uint64_t tfo_response_cookie;
1369         unsigned int *tfo_pending = NULL;
1370         int tfo_cookie_valid = 0;
1371         int tfo_response_cookie_valid = 0;
1372         bool locked;
1373
1374         INP_WLOCK_ASSERT(inp);                  /* listen socket */
1375         KASSERT((th->th_flags & (TH_RST|TH_ACK|TH_SYN)) == TH_SYN,
1376             ("%s: unexpected tcp flags", __func__));
1377
1378         /*
1379          * Combine all so/tp operations very early to drop the INP lock as
1380          * soon as possible.
1381          */
1382         so = *lsop;
1383         KASSERT(SOLISTENING(so), ("%s: %p not listening", __func__, so));
1384         tp = sototcpcb(so);
1385         cred = crhold(so->so_cred);
1386
1387 #ifdef INET6
1388         if ((inc->inc_flags & INC_ISIPV6) &&
1389             (inp->inp_flags & IN6P_AUTOFLOWLABEL))
1390                 autoflowlabel = 1;
1391 #endif
1392         ip_ttl = inp->inp_ip_ttl;
1393         ip_tos = inp->inp_ip_tos;
1394         win = so->sol_sbrcv_hiwat;
1395         ltflags = (tp->t_flags & (TF_NOOPT | TF_SIGNATURE));
1396
1397         if (V_tcp_fastopen_server_enable && IS_FASTOPEN(tp->t_flags) &&
1398             (tp->t_tfo_pending != NULL) &&
1399             (to->to_flags & TOF_FASTOPEN)) {
1400                 /*
1401                  * Limit the number of pending TFO connections to
1402                  * approximately half of the queue limit.  This prevents TFO
1403                  * SYN floods from starving the service by filling the
1404                  * listen queue with bogus TFO connections.
1405                  */
1406                 if (atomic_fetchadd_int(tp->t_tfo_pending, 1) <=
1407                     (so->sol_qlimit / 2)) {
1408                         int result;
1409
1410                         result = tcp_fastopen_check_cookie(inc,
1411                             to->to_tfo_cookie, to->to_tfo_len,
1412                             &tfo_response_cookie);
1413                         tfo_cookie_valid = (result > 0);
1414                         tfo_response_cookie_valid = (result >= 0);
1415                 }
1416
1417                 /*
1418                  * Remember the TFO pending counter as it will have to be
1419                  * decremented below if we don't make it to syncache_tfo_expand().
1420                  */
1421                 tfo_pending = tp->t_tfo_pending;
1422         }
1423
1424         /* By the time we drop the lock these should no longer be used. */
1425         so = NULL;
1426         tp = NULL;
1427
1428 #ifdef MAC
1429         if (mac_syncache_init(&maclabel) != 0) {
1430                 INP_WUNLOCK(inp);
1431                 goto done;
1432         } else
1433                 mac_syncache_create(maclabel, inp);
1434 #endif
1435         if (!tfo_cookie_valid)
1436                 INP_WUNLOCK(inp);
1437
1438         /*
1439          * Remember the IP options, if any.
1440          */
1441 #ifdef INET6
1442         if (!(inc->inc_flags & INC_ISIPV6))
1443 #endif
1444 #ifdef INET
1445                 ipopts = (m) ? ip_srcroute(m) : NULL;
1446 #else
1447                 ipopts = NULL;
1448 #endif
1449
1450 #if defined(IPSEC_SUPPORT) || defined(TCP_SIGNATURE)
1451         /*
1452          * If listening socket requested TCP digests, check that received
1453          * SYN has signature and it is correct. If signature doesn't match
1454          * or TCP_SIGNATURE support isn't enabled, drop the packet.
1455          */
1456         if (ltflags & TF_SIGNATURE) {
1457                 if ((to->to_flags & TOF_SIGNATURE) == 0) {
1458                         TCPSTAT_INC(tcps_sig_err_nosigopt);
1459                         goto done;
1460                 }
1461                 if (!TCPMD5_ENABLED() ||
1462                     TCPMD5_INPUT(m, th, to->to_signature) != 0)
1463                         goto done;
1464         }
1465 #endif  /* TCP_SIGNATURE */
1466         /*
1467          * See if we already have an entry for this connection.
1468          * If we do, resend the SYN,ACK, and reset the retransmit timer.
1469          *
1470          * XXX: should the syncache be re-initialized with the contents
1471          * of the new SYN here (which may have different options?)
1472          *
1473          * XXX: We do not check the sequence number to see if this is a
1474          * real retransmit or a new connection attempt.  The question is
1475          * how to handle such a case; either ignore it as spoofed, or
1476          * drop the current entry and create a new one?
1477          */
1478         if (syncache_cookiesonly()) {
1479                 sc = NULL;
1480                 sch = syncache_hashbucket(inc);
1481                 locked = false;
1482         } else {
1483                 sc = syncache_lookup(inc, &sch);        /* returns locked sch */
1484                 locked = true;
1485                 SCH_LOCK_ASSERT(sch);
1486         }
1487         if (sc != NULL) {
1488                 if (tfo_cookie_valid)
1489                         INP_WUNLOCK(inp);
1490                 TCPSTAT_INC(tcps_sc_dupsyn);
1491                 if (ipopts) {
1492                         /*
1493                          * If we were remembering a previous source route,
1494                          * forget it and use the new one we've been given.
1495                          */
1496                         if (sc->sc_ipopts)
1497                                 (void) m_free(sc->sc_ipopts);
1498                         sc->sc_ipopts = ipopts;
1499                 }
1500                 /*
1501                  * Update timestamp if present.
1502                  */
1503                 if ((sc->sc_flags & SCF_TIMESTAMP) && (to->to_flags & TOF_TS))
1504                         sc->sc_tsreflect = to->to_tsval;
1505                 else
1506                         sc->sc_flags &= ~SCF_TIMESTAMP;
1507 #ifdef MAC
1508                 /*
1509                  * Since we have already unconditionally allocated label
1510                  * storage, free it up.  The syncache entry will already
1511                  * have an initialized label we can use.
1512                  */
1513                 mac_syncache_destroy(&maclabel);
1514 #endif
1515                 TCP_PROBE5(receive, NULL, NULL, m, NULL, th);
1516                 /* Retransmit SYN|ACK and reset retransmit count. */
1517                 if ((s = tcp_log_addrs(&sc->sc_inc, th, NULL, NULL))) {
1518                         log(LOG_DEBUG, "%s; %s: Received duplicate SYN, "
1519                             "resetting timer and retransmitting SYN|ACK\n",
1520                             s, __func__);
1521                         free(s, M_TCPLOG);
1522                 }
1523                 if (syncache_respond(sc, m, TH_SYN|TH_ACK) == 0) {
1524                         sc->sc_rxmits = 0;
1525                         syncache_timeout(sc, sch, 1);
1526                         TCPSTAT_INC(tcps_sndacks);
1527                         TCPSTAT_INC(tcps_sndtotal);
1528                 }
1529                 SCH_UNLOCK(sch);
1530                 goto donenoprobe;
1531         }
1532
1533         if (tfo_cookie_valid) {
1534                 bzero(&scs, sizeof(scs));
1535                 sc = &scs;
1536                 goto skip_alloc;
1537         }
1538
1539         /*
1540          * Skip allocating a syncache entry if we are just going to discard
1541          * it later.
1542          */
1543         if (!locked) {
1544                 bzero(&scs, sizeof(scs));
1545                 sc = &scs;
1546         } else
1547                 sc = uma_zalloc(V_tcp_syncache.zone, M_NOWAIT | M_ZERO);
1548         if (sc == NULL) {
1549                 /*
1550                  * The zone allocator couldn't provide more entries.
1551                  * Treat this as if the cache was full; drop the oldest
1552                  * entry and insert the new one.
1553                  */
1554                 TCPSTAT_INC(tcps_sc_zonefail);
1555                 if ((sc = TAILQ_LAST(&sch->sch_bucket, sch_head)) != NULL) {
1556                         sch->sch_last_overflow = time_uptime;
1557                         syncache_drop(sc, sch);
1558                         syncache_pause(inc);
1559                 }
1560                 sc = uma_zalloc(V_tcp_syncache.zone, M_NOWAIT | M_ZERO);
1561                 if (sc == NULL) {
1562                         if (V_tcp_syncookies) {
1563                                 bzero(&scs, sizeof(scs));
1564                                 sc = &scs;
1565                         } else {
1566                                 KASSERT(locked,
1567                                     ("%s: bucket unexpectedly unlocked",
1568                                     __func__));
1569                                 SCH_UNLOCK(sch);
1570                                 if (ipopts)
1571                                         (void) m_free(ipopts);
1572                                 goto done;
1573                         }
1574                 }
1575         }
1576
1577 skip_alloc:
1578         if (!tfo_cookie_valid && tfo_response_cookie_valid)
1579                 sc->sc_tfo_cookie = &tfo_response_cookie;
1580
1581         /*
1582          * Fill in the syncache values.
1583          */
1584 #ifdef MAC
1585         sc->sc_label = maclabel;
1586 #endif
1587         sc->sc_cred = cred;
1588         cred = NULL;
1589         sc->sc_ipopts = ipopts;
1590         bcopy(inc, &sc->sc_inc, sizeof(struct in_conninfo));
1591 #ifdef INET6
1592         if (!(inc->inc_flags & INC_ISIPV6))
1593 #endif
1594         {
1595                 sc->sc_ip_tos = ip_tos;
1596                 sc->sc_ip_ttl = ip_ttl;
1597         }
1598 #ifdef TCP_OFFLOAD
1599         sc->sc_tod = tod;
1600         sc->sc_todctx = todctx;
1601 #endif
1602         sc->sc_irs = th->th_seq;
1603         sc->sc_flags = 0;
1604         sc->sc_flowlabel = 0;
1605
1606         /*
1607          * Initial receive window: clip sbspace to [0 .. TCP_MAXWIN].
1608          * win was derived from socket earlier in the function.
1609          */
1610         win = imax(win, 0);
1611         win = imin(win, TCP_MAXWIN);
1612         sc->sc_wnd = win;
1613
1614         if (V_tcp_do_rfc1323) {
1615                 /*
1616                  * A timestamp received in a SYN makes
1617                  * it ok to send timestamp requests and replies.
1618                  */
1619                 if (to->to_flags & TOF_TS) {
1620                         sc->sc_tsreflect = to->to_tsval;
1621                         sc->sc_flags |= SCF_TIMESTAMP;
1622                         sc->sc_tsoff = tcp_new_ts_offset(inc);
1623                 }
1624                 if (to->to_flags & TOF_SCALE) {
1625                         int wscale = 0;
1626
1627                         /*
1628                          * Pick the smallest possible scaling factor that
1629                          * will still allow us to scale up to sb_max, aka
1630                          * kern.ipc.maxsockbuf.
1631                          *
1632                          * We do this because there are broken firewalls that
1633                          * will corrupt the window scale option, leading to
1634                          * the other endpoint believing that our advertised
1635                          * window is unscaled.  At scale factors larger than
1636                          * 5 the unscaled window will drop below 1500 bytes,
1637                          * leading to serious problems when traversing these
1638                          * broken firewalls.
1639                          *
1640                          * With the default maxsockbuf of 256K, a scale factor
1641                          * of 3 will be chosen by this algorithm.  Those who
1642                          * choose a larger maxsockbuf should watch out
1643                          * for the compatibility problems mentioned above.
1644                          *
1645                          * RFC1323: The Window field in a SYN (i.e., a <SYN>
1646                          * or <SYN,ACK>) segment itself is never scaled.
1647                          */
1648                         while (wscale < TCP_MAX_WINSHIFT &&
1649                             (TCP_MAXWIN << wscale) < sb_max)
1650                                 wscale++;
1651                         sc->sc_requested_r_scale = wscale;
1652                         sc->sc_requested_s_scale = to->to_wscale;
1653                         sc->sc_flags |= SCF_WINSCALE;
1654                 }
1655         }
1656 #if defined(IPSEC_SUPPORT) || defined(TCP_SIGNATURE)
1657         /*
1658          * If listening socket requested TCP digests, flag this in the
1659          * syncache so that syncache_respond() will do the right thing
1660          * with the SYN+ACK.
1661          */
1662         if (ltflags & TF_SIGNATURE)
1663                 sc->sc_flags |= SCF_SIGNATURE;
1664 #endif  /* TCP_SIGNATURE */
1665         if (to->to_flags & TOF_SACKPERM)
1666                 sc->sc_flags |= SCF_SACK;
1667         if (to->to_flags & TOF_MSS)
1668                 sc->sc_peer_mss = to->to_mss;   /* peer mss may be zero */
1669         if (ltflags & TF_NOOPT)
1670                 sc->sc_flags |= SCF_NOOPT;
1671         if ((th->th_flags & (TH_ECE|TH_CWR)) && V_tcp_do_ecn)
1672                 sc->sc_flags |= SCF_ECN;
1673
1674         if (V_tcp_syncookies)
1675                 sc->sc_iss = syncookie_generate(sch, sc);
1676         else
1677                 sc->sc_iss = arc4random();
1678 #ifdef INET6
1679         if (autoflowlabel) {
1680                 if (V_tcp_syncookies)
1681                         sc->sc_flowlabel = sc->sc_iss;
1682                 else
1683                         sc->sc_flowlabel = ip6_randomflowlabel();
1684                 sc->sc_flowlabel = htonl(sc->sc_flowlabel) & IPV6_FLOWLABEL_MASK;
1685         }
1686 #endif
1687         if (locked)
1688                 SCH_UNLOCK(sch);
1689
1690         if (tfo_cookie_valid) {
1691                 syncache_tfo_expand(sc, lsop, m, tfo_response_cookie);
1692                 /* INP_WUNLOCK(inp) will be performed by the caller */
1693                 rv = 1;
1694                 goto tfo_expanded;
1695         }
1696
1697         TCP_PROBE5(receive, NULL, NULL, m, NULL, th);
1698         /*
1699          * Do a standard 3-way handshake.
1700          */
1701         if (syncache_respond(sc, m, TH_SYN|TH_ACK) == 0) {
1702                 if (V_tcp_syncookies && V_tcp_syncookiesonly && sc != &scs)
1703                         syncache_free(sc);
1704                 else if (sc != &scs)
1705                         syncache_insert(sc, sch);   /* locks and unlocks sch */
1706                 TCPSTAT_INC(tcps_sndacks);
1707                 TCPSTAT_INC(tcps_sndtotal);
1708         } else {
1709                 if (sc != &scs)
1710                         syncache_free(sc);
1711                 TCPSTAT_INC(tcps_sc_dropped);
1712         }
1713         goto donenoprobe;
1714
1715 done:
1716         TCP_PROBE5(receive, NULL, NULL, m, NULL, th);
1717 donenoprobe:
1718         if (m) {
1719                 *lsop = NULL;
1720                 m_freem(m);
1721         }
1722         /*
1723          * If tfo_pending is not NULL here, then a TFO SYN that did not
1724          * result in a new socket was processed and the associated pending
1725          * counter has not yet been decremented.  All such TFO processing paths
1726          * transit this point.
1727          */
1728         if (tfo_pending != NULL)
1729                 tcp_fastopen_decrement_counter(tfo_pending);
1730
1731 tfo_expanded:
1732         if (cred != NULL)
1733                 crfree(cred);
1734 #ifdef MAC
1735         if (sc == &scs)
1736                 mac_syncache_destroy(&maclabel);
1737 #endif
1738         return (rv);
1739 }
1740
1741 /*
1742  * Send SYN|ACK or ACK to the peer.  Either in response to a peer's segment,
1743  * i.e. m0 != NULL, or upon 3WHS ACK timeout, i.e. m0 == NULL.
1744  */
1745 static int
1746 syncache_respond(struct syncache *sc, const struct mbuf *m0, int flags)
1747 {
1748         struct ip *ip = NULL;
1749         struct mbuf *m;
1750         struct tcphdr *th = NULL;
1751         int optlen, error = 0;  /* Make compiler happy */
1752         u_int16_t hlen, tlen, mssopt;
1753         struct tcpopt to;
1754 #ifdef INET6
1755         struct ip6_hdr *ip6 = NULL;
1756 #endif
1757
1758         NET_EPOCH_ASSERT();
1759
1760         hlen =
1761 #ifdef INET6
1762                (sc->sc_inc.inc_flags & INC_ISIPV6) ? sizeof(struct ip6_hdr) :
1763 #endif
1764                 sizeof(struct ip);
1765         tlen = hlen + sizeof(struct tcphdr);
1766
1767         /* Determine MSS we advertize to other end of connection. */
1768         mssopt = max(tcp_mssopt(&sc->sc_inc), V_tcp_minmss);
1769
1770         /* XXX: Assume that the entire packet will fit in a header mbuf. */
1771         KASSERT(max_linkhdr + tlen + TCP_MAXOLEN <= MHLEN,
1772             ("syncache: mbuf too small"));
1773
1774         /* Create the IP+TCP header from scratch. */
1775         m = m_gethdr(M_NOWAIT, MT_DATA);
1776         if (m == NULL)
1777                 return (ENOBUFS);
1778 #ifdef MAC
1779         mac_syncache_create_mbuf(sc->sc_label, m);
1780 #endif
1781         m->m_data += max_linkhdr;
1782         m->m_len = tlen;
1783         m->m_pkthdr.len = tlen;
1784         m->m_pkthdr.rcvif = NULL;
1785
1786 #ifdef INET6
1787         if (sc->sc_inc.inc_flags & INC_ISIPV6) {
1788                 ip6 = mtod(m, struct ip6_hdr *);
1789                 ip6->ip6_vfc = IPV6_VERSION;
1790                 ip6->ip6_nxt = IPPROTO_TCP;
1791                 ip6->ip6_src = sc->sc_inc.inc6_laddr;
1792                 ip6->ip6_dst = sc->sc_inc.inc6_faddr;
1793                 ip6->ip6_plen = htons(tlen - hlen);
1794                 /* ip6_hlim is set after checksum */
1795                 ip6->ip6_flow &= ~IPV6_FLOWLABEL_MASK;
1796                 ip6->ip6_flow |= sc->sc_flowlabel;
1797
1798                 th = (struct tcphdr *)(ip6 + 1);
1799         }
1800 #endif
1801 #if defined(INET6) && defined(INET)
1802         else
1803 #endif
1804 #ifdef INET
1805         {
1806                 ip = mtod(m, struct ip *);
1807                 ip->ip_v = IPVERSION;
1808                 ip->ip_hl = sizeof(struct ip) >> 2;
1809                 ip->ip_len = htons(tlen);
1810                 ip->ip_id = 0;
1811                 ip->ip_off = 0;
1812                 ip->ip_sum = 0;
1813                 ip->ip_p = IPPROTO_TCP;
1814                 ip->ip_src = sc->sc_inc.inc_laddr;
1815                 ip->ip_dst = sc->sc_inc.inc_faddr;
1816                 ip->ip_ttl = sc->sc_ip_ttl;
1817                 ip->ip_tos = sc->sc_ip_tos;
1818
1819                 /*
1820                  * See if we should do MTU discovery.  Route lookups are
1821                  * expensive, so we will only unset the DF bit if:
1822                  *
1823                  *      1) path_mtu_discovery is disabled
1824                  *      2) the SCF_UNREACH flag has been set
1825                  */
1826                 if (V_path_mtu_discovery && ((sc->sc_flags & SCF_UNREACH) == 0))
1827                        ip->ip_off |= htons(IP_DF);
1828
1829                 th = (struct tcphdr *)(ip + 1);
1830         }
1831 #endif /* INET */
1832         th->th_sport = sc->sc_inc.inc_lport;
1833         th->th_dport = sc->sc_inc.inc_fport;
1834
1835         if (flags & TH_SYN)
1836                 th->th_seq = htonl(sc->sc_iss);
1837         else
1838                 th->th_seq = htonl(sc->sc_iss + 1);
1839         th->th_ack = htonl(sc->sc_irs + 1);
1840         th->th_off = sizeof(struct tcphdr) >> 2;
1841         th->th_x2 = 0;
1842         th->th_flags = flags;
1843         th->th_win = htons(sc->sc_wnd);
1844         th->th_urp = 0;
1845
1846         if ((flags & TH_SYN) && (sc->sc_flags & SCF_ECN)) {
1847                 th->th_flags |= TH_ECE;
1848                 TCPSTAT_INC(tcps_ecn_shs);
1849         }
1850
1851         /* Tack on the TCP options. */
1852         if ((sc->sc_flags & SCF_NOOPT) == 0) {
1853                 to.to_flags = 0;
1854
1855                 if (flags & TH_SYN) {
1856                         to.to_mss = mssopt;
1857                         to.to_flags = TOF_MSS;
1858                         if (sc->sc_flags & SCF_WINSCALE) {
1859                                 to.to_wscale = sc->sc_requested_r_scale;
1860                                 to.to_flags |= TOF_SCALE;
1861                         }
1862                         if (sc->sc_flags & SCF_SACK)
1863                                 to.to_flags |= TOF_SACKPERM;
1864 #if defined(IPSEC_SUPPORT) || defined(TCP_SIGNATURE)
1865                         if (sc->sc_flags & SCF_SIGNATURE)
1866                                 to.to_flags |= TOF_SIGNATURE;
1867 #endif
1868                         if (sc->sc_tfo_cookie) {
1869                                 to.to_flags |= TOF_FASTOPEN;
1870                                 to.to_tfo_len = TCP_FASTOPEN_COOKIE_LEN;
1871                                 to.to_tfo_cookie = sc->sc_tfo_cookie;
1872                                 /* don't send cookie again when retransmitting response */
1873                                 sc->sc_tfo_cookie = NULL;
1874                         }
1875                 }
1876                 if (sc->sc_flags & SCF_TIMESTAMP) {
1877                         to.to_tsval = sc->sc_tsoff + tcp_ts_getticks();
1878                         to.to_tsecr = sc->sc_tsreflect;
1879                         to.to_flags |= TOF_TS;
1880                 }
1881                 optlen = tcp_addoptions(&to, (u_char *)(th + 1));
1882
1883                 /* Adjust headers by option size. */
1884                 th->th_off = (sizeof(struct tcphdr) + optlen) >> 2;
1885                 m->m_len += optlen;
1886                 m->m_pkthdr.len += optlen;
1887 #ifdef INET6
1888                 if (sc->sc_inc.inc_flags & INC_ISIPV6)
1889                         ip6->ip6_plen = htons(ntohs(ip6->ip6_plen) + optlen);
1890                 else
1891 #endif
1892                         ip->ip_len = htons(ntohs(ip->ip_len) + optlen);
1893 #if defined(IPSEC_SUPPORT) || defined(TCP_SIGNATURE)
1894                 if (sc->sc_flags & SCF_SIGNATURE) {
1895                         KASSERT(to.to_flags & TOF_SIGNATURE,
1896                             ("tcp_addoptions() didn't set tcp_signature"));
1897
1898                         /* NOTE: to.to_signature is inside of mbuf */
1899                         if (!TCPMD5_ENABLED() ||
1900                             TCPMD5_OUTPUT(m, th, to.to_signature) != 0) {
1901                                 m_freem(m);
1902                                 return (EACCES);
1903                         }
1904                 }
1905 #endif
1906         } else
1907                 optlen = 0;
1908
1909         M_SETFIB(m, sc->sc_inc.inc_fibnum);
1910         m->m_pkthdr.csum_data = offsetof(struct tcphdr, th_sum);
1911         /*
1912          * If we have peer's SYN and it has a flowid, then let's assign it to
1913          * our SYN|ACK.  ip6_output() and ip_output() will not assign flowid
1914          * to SYN|ACK due to lack of inp here.
1915          */
1916         if (m0 != NULL && M_HASHTYPE_GET(m0) != M_HASHTYPE_NONE) {
1917                 m->m_pkthdr.flowid = m0->m_pkthdr.flowid;
1918                 M_HASHTYPE_SET(m, M_HASHTYPE_GET(m0));
1919         }
1920 #ifdef INET6
1921         if (sc->sc_inc.inc_flags & INC_ISIPV6) {
1922                 m->m_pkthdr.csum_flags = CSUM_TCP_IPV6;
1923                 th->th_sum = in6_cksum_pseudo(ip6, tlen + optlen - hlen,
1924                     IPPROTO_TCP, 0);
1925                 ip6->ip6_hlim = in6_selecthlim(NULL, NULL);
1926 #ifdef TCP_OFFLOAD
1927                 if (ADDED_BY_TOE(sc)) {
1928                         struct toedev *tod = sc->sc_tod;
1929
1930                         error = tod->tod_syncache_respond(tod, sc->sc_todctx, m);
1931
1932                         return (error);
1933                 }
1934 #endif
1935                 TCP_PROBE5(send, NULL, NULL, ip6, NULL, th);
1936                 error = ip6_output(m, NULL, NULL, 0, NULL, NULL, NULL);
1937         }
1938 #endif
1939 #if defined(INET6) && defined(INET)
1940         else
1941 #endif
1942 #ifdef INET
1943         {
1944                 m->m_pkthdr.csum_flags = CSUM_TCP;
1945                 th->th_sum = in_pseudo(ip->ip_src.s_addr, ip->ip_dst.s_addr,
1946                     htons(tlen + optlen - hlen + IPPROTO_TCP));
1947 #ifdef TCP_OFFLOAD
1948                 if (ADDED_BY_TOE(sc)) {
1949                         struct toedev *tod = sc->sc_tod;
1950
1951                         error = tod->tod_syncache_respond(tod, sc->sc_todctx, m);
1952
1953                         return (error);
1954                 }
1955 #endif
1956                 TCP_PROBE5(send, NULL, NULL, ip, NULL, th);
1957                 error = ip_output(m, sc->sc_ipopts, NULL, 0, NULL, NULL);
1958         }
1959 #endif
1960         return (error);
1961 }
1962
1963 /*
1964  * The purpose of syncookies is to handle spoofed SYN flooding DoS attacks
1965  * that exceed the capacity of the syncache by avoiding the storage of any
1966  * of the SYNs we receive.  Syncookies defend against blind SYN flooding
1967  * attacks where the attacker does not have access to our responses.
1968  *
1969  * Syncookies encode and include all necessary information about the
1970  * connection setup within the SYN|ACK that we send back.  That way we
1971  * can avoid keeping any local state until the ACK to our SYN|ACK returns
1972  * (if ever).  Normally the syncache and syncookies are running in parallel
1973  * with the latter taking over when the former is exhausted.  When matching
1974  * syncache entry is found the syncookie is ignored.
1975  *
1976  * The only reliable information persisting the 3WHS is our initial sequence
1977  * number ISS of 32 bits.  Syncookies embed a cryptographically sufficient
1978  * strong hash (MAC) value and a few bits of TCP SYN options in the ISS
1979  * of our SYN|ACK.  The MAC can be recomputed when the ACK to our SYN|ACK
1980  * returns and signifies a legitimate connection if it matches the ACK.
1981  *
1982  * The available space of 32 bits to store the hash and to encode the SYN
1983  * option information is very tight and we should have at least 24 bits for
1984  * the MAC to keep the number of guesses by blind spoofing reasonably high.
1985  *
1986  * SYN option information we have to encode to fully restore a connection:
1987  * MSS: is imporant to chose an optimal segment size to avoid IP level
1988  *   fragmentation along the path.  The common MSS values can be encoded
1989  *   in a 3-bit table.  Uncommon values are captured by the next lower value
1990  *   in the table leading to a slight increase in packetization overhead.
1991  * WSCALE: is necessary to allow large windows to be used for high delay-
1992  *   bandwidth product links.  Not scaling the window when it was initially
1993  *   negotiated is bad for performance as lack of scaling further decreases
1994  *   the apparent available send window.  We only need to encode the WSCALE
1995  *   we received from the remote end.  Our end can be recalculated at any
1996  *   time.  The common WSCALE values can be encoded in a 3-bit table.
1997  *   Uncommon values are captured by the next lower value in the table
1998  *   making us under-estimate the available window size halving our
1999  *   theoretically possible maximum throughput for that connection.
2000  * SACK: Greatly assists in packet loss recovery and requires 1 bit.
2001  * TIMESTAMP and SIGNATURE is not encoded because they are permanent options
2002  *   that are included in all segments on a connection.  We enable them when
2003  *   the ACK has them.
2004  *
2005  * Security of syncookies and attack vectors:
2006  *
2007  * The MAC is computed over (faddr||laddr||fport||lport||irs||flags||secmod)
2008  * together with the gloabl secret to make it unique per connection attempt.
2009  * Thus any change of any of those parameters results in a different MAC output
2010  * in an unpredictable way unless a collision is encountered.  24 bits of the
2011  * MAC are embedded into the ISS.
2012  *
2013  * To prevent replay attacks two rotating global secrets are updated with a
2014  * new random value every 15 seconds.  The life-time of a syncookie is thus
2015  * 15-30 seconds.
2016  *
2017  * Vector 1: Attacking the secret.  This requires finding a weakness in the
2018  * MAC itself or the way it is used here.  The attacker can do a chosen plain
2019  * text attack by varying and testing the all parameters under his control.
2020  * The strength depends on the size and randomness of the secret, and the
2021  * cryptographic security of the MAC function.  Due to the constant updating
2022  * of the secret the attacker has at most 29.999 seconds to find the secret
2023  * and launch spoofed connections.  After that he has to start all over again.
2024  *
2025  * Vector 2: Collision attack on the MAC of a single ACK.  With a 24 bit MAC
2026  * size an average of 4,823 attempts are required for a 50% chance of success
2027  * to spoof a single syncookie (birthday collision paradox).  However the
2028  * attacker is blind and doesn't know if one of his attempts succeeded unless
2029  * he has a side channel to interfere success from.  A single connection setup
2030  * success average of 90% requires 8,790 packets, 99.99% requires 17,578 packets.
2031  * This many attempts are required for each one blind spoofed connection.  For
2032  * every additional spoofed connection he has to launch another N attempts.
2033  * Thus for a sustained rate 100 spoofed connections per second approximately
2034  * 1,800,000 packets per second would have to be sent.
2035  *
2036  * NB: The MAC function should be fast so that it doesn't become a CPU
2037  * exhaustion attack vector itself.
2038  *
2039  * References:
2040  *  RFC4987 TCP SYN Flooding Attacks and Common Mitigations
2041  *  SYN cookies were first proposed by cryptographer Dan J. Bernstein in 1996
2042  *   http://cr.yp.to/syncookies.html    (overview)
2043  *   http://cr.yp.to/syncookies/archive (details)
2044  *
2045  *
2046  * Schematic construction of a syncookie enabled Initial Sequence Number:
2047  *  0        1         2         3
2048  *  12345678901234567890123456789012
2049  * |xxxxxxxxxxxxxxxxxxxxxxxxWWWMMMSP|
2050  *
2051  *  x 24 MAC (truncated)
2052  *  W  3 Send Window Scale index
2053  *  M  3 MSS index
2054  *  S  1 SACK permitted
2055  *  P  1 Odd/even secret
2056  */
2057
2058 /*
2059  * Distribution and probability of certain MSS values.  Those in between are
2060  * rounded down to the next lower one.
2061  * [An Analysis of TCP Maximum Segment Sizes, S. Alcock and R. Nelson, 2011]
2062  *                            .2%  .3%   5%    7%    7%    20%   15%   45%
2063  */
2064 static int tcp_sc_msstab[] = { 216, 536, 1200, 1360, 1400, 1440, 1452, 1460 };
2065
2066 /*
2067  * Distribution and probability of certain WSCALE values.  We have to map the
2068  * (send) window scale (shift) option with a range of 0-14 from 4 bits into 3
2069  * bits based on prevalence of certain values.  Where we don't have an exact
2070  * match for are rounded down to the next lower one letting us under-estimate
2071  * the true available window.  At the moment this would happen only for the
2072  * very uncommon values 3, 5 and those above 8 (more than 16MB socket buffer
2073  * and window size).  The absence of the WSCALE option (no scaling in either
2074  * direction) is encoded with index zero.
2075  * [WSCALE values histograms, Allman, 2012]
2076  *                            X 10 10 35  5  6 14 10%   by host
2077  *                            X 11  4  5  5 18 49  3%   by connections
2078  */
2079 static int tcp_sc_wstab[] = { 0, 0, 1, 2, 4, 6, 7, 8 };
2080
2081 /*
2082  * Compute the MAC for the SYN cookie.  SIPHASH-2-4 is chosen for its speed
2083  * and good cryptographic properties.
2084  */
2085 static uint32_t
2086 syncookie_mac(struct in_conninfo *inc, tcp_seq irs, uint8_t flags,
2087     uint8_t *secbits, uintptr_t secmod)
2088 {
2089         SIPHASH_CTX ctx;
2090         uint32_t siphash[2];
2091
2092         SipHash24_Init(&ctx);
2093         SipHash_SetKey(&ctx, secbits);
2094         switch (inc->inc_flags & INC_ISIPV6) {
2095 #ifdef INET
2096         case 0:
2097                 SipHash_Update(&ctx, &inc->inc_faddr, sizeof(inc->inc_faddr));
2098                 SipHash_Update(&ctx, &inc->inc_laddr, sizeof(inc->inc_laddr));
2099                 break;
2100 #endif
2101 #ifdef INET6
2102         case INC_ISIPV6:
2103                 SipHash_Update(&ctx, &inc->inc6_faddr, sizeof(inc->inc6_faddr));
2104                 SipHash_Update(&ctx, &inc->inc6_laddr, sizeof(inc->inc6_laddr));
2105                 break;
2106 #endif
2107         }
2108         SipHash_Update(&ctx, &inc->inc_fport, sizeof(inc->inc_fport));
2109         SipHash_Update(&ctx, &inc->inc_lport, sizeof(inc->inc_lport));
2110         SipHash_Update(&ctx, &irs, sizeof(irs));
2111         SipHash_Update(&ctx, &flags, sizeof(flags));
2112         SipHash_Update(&ctx, &secmod, sizeof(secmod));
2113         SipHash_Final((u_int8_t *)&siphash, &ctx);
2114
2115         return (siphash[0] ^ siphash[1]);
2116 }
2117
2118 static tcp_seq
2119 syncookie_generate(struct syncache_head *sch, struct syncache *sc)
2120 {
2121         u_int i, secbit, wscale;
2122         uint32_t iss, hash;
2123         uint8_t *secbits;
2124         union syncookie cookie;
2125
2126         cookie.cookie = 0;
2127
2128         /* Map our computed MSS into the 3-bit index. */
2129         for (i = nitems(tcp_sc_msstab) - 1;
2130              tcp_sc_msstab[i] > sc->sc_peer_mss && i > 0;
2131              i--)
2132                 ;
2133         cookie.flags.mss_idx = i;
2134
2135         /*
2136          * Map the send window scale into the 3-bit index but only if
2137          * the wscale option was received.
2138          */
2139         if (sc->sc_flags & SCF_WINSCALE) {
2140                 wscale = sc->sc_requested_s_scale;
2141                 for (i = nitems(tcp_sc_wstab) - 1;
2142                     tcp_sc_wstab[i] > wscale && i > 0;
2143                      i--)
2144                         ;
2145                 cookie.flags.wscale_idx = i;
2146         }
2147
2148         /* Can we do SACK? */
2149         if (sc->sc_flags & SCF_SACK)
2150                 cookie.flags.sack_ok = 1;
2151
2152         /* Which of the two secrets to use. */
2153         secbit = V_tcp_syncache.secret.oddeven & 0x1;
2154         cookie.flags.odd_even = secbit;
2155
2156         secbits = V_tcp_syncache.secret.key[secbit];
2157         hash = syncookie_mac(&sc->sc_inc, sc->sc_irs, cookie.cookie, secbits,
2158             (uintptr_t)sch);
2159
2160         /*
2161          * Put the flags into the hash and XOR them to get better ISS number
2162          * variance.  This doesn't enhance the cryptographic strength and is
2163          * done to prevent the 8 cookie bits from showing up directly on the
2164          * wire.
2165          */
2166         iss = hash & ~0xff;
2167         iss |= cookie.cookie ^ (hash >> 24);
2168
2169         TCPSTAT_INC(tcps_sc_sendcookie);
2170         return (iss);
2171 }
2172
2173 static struct syncache *
2174 syncookie_lookup(struct in_conninfo *inc, struct syncache_head *sch,
2175     struct syncache *sc, struct tcphdr *th, struct tcpopt *to,
2176     struct socket *lso)
2177 {
2178         uint32_t hash;
2179         uint8_t *secbits;
2180         tcp_seq ack, seq;
2181         int wnd, wscale = 0;
2182         union syncookie cookie;
2183
2184         /*
2185          * Pull information out of SYN-ACK/ACK and revert sequence number
2186          * advances.
2187          */
2188         ack = th->th_ack - 1;
2189         seq = th->th_seq - 1;
2190
2191         /*
2192          * Unpack the flags containing enough information to restore the
2193          * connection.
2194          */
2195         cookie.cookie = (ack & 0xff) ^ (ack >> 24);
2196
2197         /* Which of the two secrets to use. */
2198         secbits = V_tcp_syncache.secret.key[cookie.flags.odd_even];
2199
2200         hash = syncookie_mac(inc, seq, cookie.cookie, secbits, (uintptr_t)sch);
2201
2202         /* The recomputed hash matches the ACK if this was a genuine cookie. */
2203         if ((ack & ~0xff) != (hash & ~0xff))
2204                 return (NULL);
2205
2206         /* Fill in the syncache values. */
2207         sc->sc_flags = 0;
2208         bcopy(inc, &sc->sc_inc, sizeof(struct in_conninfo));
2209         sc->sc_ipopts = NULL;
2210
2211         sc->sc_irs = seq;
2212         sc->sc_iss = ack;
2213
2214         switch (inc->inc_flags & INC_ISIPV6) {
2215 #ifdef INET
2216         case 0:
2217                 sc->sc_ip_ttl = sotoinpcb(lso)->inp_ip_ttl;
2218                 sc->sc_ip_tos = sotoinpcb(lso)->inp_ip_tos;
2219                 break;
2220 #endif
2221 #ifdef INET6
2222         case INC_ISIPV6:
2223                 if (sotoinpcb(lso)->inp_flags & IN6P_AUTOFLOWLABEL)
2224                         sc->sc_flowlabel = sc->sc_iss & IPV6_FLOWLABEL_MASK;
2225                 break;
2226 #endif
2227         }
2228
2229         sc->sc_peer_mss = tcp_sc_msstab[cookie.flags.mss_idx];
2230
2231         /* We can simply recompute receive window scale we sent earlier. */
2232         while (wscale < TCP_MAX_WINSHIFT && (TCP_MAXWIN << wscale) < sb_max)
2233                 wscale++;
2234
2235         /* Only use wscale if it was enabled in the orignal SYN. */
2236         if (cookie.flags.wscale_idx > 0) {
2237                 sc->sc_requested_r_scale = wscale;
2238                 sc->sc_requested_s_scale = tcp_sc_wstab[cookie.flags.wscale_idx];
2239                 sc->sc_flags |= SCF_WINSCALE;
2240         }
2241
2242         wnd = lso->sol_sbrcv_hiwat;
2243         wnd = imax(wnd, 0);
2244         wnd = imin(wnd, TCP_MAXWIN);
2245         sc->sc_wnd = wnd;
2246
2247         if (cookie.flags.sack_ok)
2248                 sc->sc_flags |= SCF_SACK;
2249
2250         if (to->to_flags & TOF_TS) {
2251                 sc->sc_flags |= SCF_TIMESTAMP;
2252                 sc->sc_tsreflect = to->to_tsval;
2253                 sc->sc_tsoff = tcp_new_ts_offset(inc);
2254         }
2255
2256         if (to->to_flags & TOF_SIGNATURE)
2257                 sc->sc_flags |= SCF_SIGNATURE;
2258
2259         sc->sc_rxmits = 0;
2260
2261         TCPSTAT_INC(tcps_sc_recvcookie);
2262         return (sc);
2263 }
2264
2265 #ifdef INVARIANTS
2266 static int
2267 syncookie_cmp(struct in_conninfo *inc, struct syncache_head *sch,
2268     struct syncache *sc, struct tcphdr *th, struct tcpopt *to,
2269     struct socket *lso)
2270 {
2271         struct syncache scs, *scx;
2272         char *s;
2273
2274         bzero(&scs, sizeof(scs));
2275         scx = syncookie_lookup(inc, sch, &scs, th, to, lso);
2276
2277         if ((s = tcp_log_addrs(inc, th, NULL, NULL)) == NULL)
2278                 return (0);
2279
2280         if (scx != NULL) {
2281                 if (sc->sc_peer_mss != scx->sc_peer_mss)
2282                         log(LOG_DEBUG, "%s; %s: mss different %i vs %i\n",
2283                             s, __func__, sc->sc_peer_mss, scx->sc_peer_mss);
2284
2285                 if (sc->sc_requested_r_scale != scx->sc_requested_r_scale)
2286                         log(LOG_DEBUG, "%s; %s: rwscale different %i vs %i\n",
2287                             s, __func__, sc->sc_requested_r_scale,
2288                             scx->sc_requested_r_scale);
2289
2290                 if (sc->sc_requested_s_scale != scx->sc_requested_s_scale)
2291                         log(LOG_DEBUG, "%s; %s: swscale different %i vs %i\n",
2292                             s, __func__, sc->sc_requested_s_scale,
2293                             scx->sc_requested_s_scale);
2294
2295                 if ((sc->sc_flags & SCF_SACK) != (scx->sc_flags & SCF_SACK))
2296                         log(LOG_DEBUG, "%s; %s: SACK different\n", s, __func__);
2297         }
2298
2299         if (s != NULL)
2300                 free(s, M_TCPLOG);
2301         return (0);
2302 }
2303 #endif /* INVARIANTS */
2304
2305 static void
2306 syncookie_reseed(void *arg)
2307 {
2308         struct tcp_syncache *sc = arg;
2309         uint8_t *secbits;
2310         int secbit;
2311
2312         /*
2313          * Reseeding the secret doesn't have to be protected by a lock.
2314          * It only must be ensured that the new random values are visible
2315          * to all CPUs in a SMP environment.  The atomic with release
2316          * semantics ensures that.
2317          */
2318         secbit = (sc->secret.oddeven & 0x1) ? 0 : 1;
2319         secbits = sc->secret.key[secbit];
2320         arc4rand(secbits, SYNCOOKIE_SECRET_SIZE, 0);
2321         atomic_add_rel_int(&sc->secret.oddeven, 1);
2322
2323         /* Reschedule ourself. */
2324         callout_schedule(&sc->secret.reseed, SYNCOOKIE_LIFETIME * hz);
2325 }
2326
2327 /*
2328  * We have overflowed a bucket. Let's pause dealing with the syncache.
2329  * This function will increment the bucketoverflow statistics appropriately
2330  * (once per pause when pausing is enabled; otherwise, once per overflow).
2331  */
2332 static void
2333 syncache_pause(struct in_conninfo *inc)
2334 {
2335         time_t delta;
2336         const char *s;
2337
2338         /* XXX:
2339          * 2. Add sysctl read here so we don't get the benefit of this
2340          * change without the new sysctl.
2341          */
2342
2343         /*
2344          * Try an unlocked read. If we already know that another thread
2345          * has activated the feature, there is no need to proceed.
2346          */
2347         if (V_tcp_syncache.paused)
2348                 return;
2349
2350         /* Are cookied enabled? If not, we can't pause. */
2351         if (!V_tcp_syncookies) {
2352                 TCPSTAT_INC(tcps_sc_bucketoverflow);
2353                 return;
2354         }
2355
2356         /*
2357          * We may be the first thread to find an overflow. Get the lock
2358          * and evaluate if we need to take action.
2359          */
2360         mtx_lock(&V_tcp_syncache.pause_mtx);
2361         if (V_tcp_syncache.paused) {
2362                 mtx_unlock(&V_tcp_syncache.pause_mtx);
2363                 return;
2364         }
2365
2366         /* Activate protection. */
2367         V_tcp_syncache.paused = true;
2368         TCPSTAT_INC(tcps_sc_bucketoverflow);
2369
2370         /*
2371          * Determine the last backoff time. If we are seeing a re-newed
2372          * attack within that same time after last reactivating the syncache,
2373          * consider it an extension of the same attack.
2374          */
2375         delta = TCP_SYNCACHE_PAUSE_TIME << V_tcp_syncache.pause_backoff;
2376         if (V_tcp_syncache.pause_until + delta - time_uptime > 0) {
2377                 if (V_tcp_syncache.pause_backoff < TCP_SYNCACHE_MAX_BACKOFF) {
2378                         delta <<= 1;
2379                         V_tcp_syncache.pause_backoff++;
2380                 }
2381         } else {
2382                 delta = TCP_SYNCACHE_PAUSE_TIME;
2383                 V_tcp_syncache.pause_backoff = 0;
2384         }
2385
2386         /* Log a warning, including IP addresses, if able. */
2387         if (inc != NULL)
2388                 s = tcp_log_addrs(inc, NULL, NULL, NULL);
2389         else
2390                 s = (const char *)NULL;
2391         log(LOG_WARNING, "TCP syncache overflow detected; using syncookies for "
2392             "the next %lld seconds%s%s%s\n", (long long)delta,
2393             (s != NULL) ? " (last SYN: " : "", (s != NULL) ? s : "",
2394             (s != NULL) ? ")" : "");
2395         free(__DECONST(void *, s), M_TCPLOG);
2396
2397         /* Use the calculated delta to set a new pause time. */
2398         V_tcp_syncache.pause_until = time_uptime + delta;
2399         callout_reset(&V_tcp_syncache.pause_co, delta * hz, syncache_unpause,
2400             &V_tcp_syncache);
2401         mtx_unlock(&V_tcp_syncache.pause_mtx);
2402 }
2403
2404 /* Evaluate whether we need to unpause. */
2405 static void
2406 syncache_unpause(void *arg)
2407 {
2408         struct tcp_syncache *sc;
2409         time_t delta;
2410
2411         sc = arg;
2412         mtx_assert(&sc->pause_mtx, MA_OWNED | MA_NOTRECURSED);
2413         callout_deactivate(&sc->pause_co);
2414
2415         /*
2416          * Check to make sure we are not running early. If the pause
2417          * time has expired, then deactivate the protection.
2418          */
2419         if ((delta = sc->pause_until - time_uptime) > 0)
2420                 callout_schedule(&sc->pause_co, delta * hz);
2421         else
2422                 sc->paused = false;
2423 }
2424
2425 /*
2426  * Exports the syncache entries to userland so that netstat can display
2427  * them alongside the other sockets.  This function is intended to be
2428  * called only from tcp_pcblist.
2429  *
2430  * Due to concurrency on an active system, the number of pcbs exported
2431  * may have no relation to max_pcbs.  max_pcbs merely indicates the
2432  * amount of space the caller allocated for this function to use.
2433  */
2434 int
2435 syncache_pcblist(struct sysctl_req *req)
2436 {
2437         struct xtcpcb xt;
2438         struct syncache *sc;
2439         struct syncache_head *sch;
2440         int error, i;
2441
2442         bzero(&xt, sizeof(xt));
2443         xt.xt_len = sizeof(xt);
2444         xt.t_state = TCPS_SYN_RECEIVED;
2445         xt.xt_inp.xi_socket.xso_protocol = IPPROTO_TCP;
2446         xt.xt_inp.xi_socket.xso_len = sizeof (struct xsocket);
2447         xt.xt_inp.xi_socket.so_type = SOCK_STREAM;
2448         xt.xt_inp.xi_socket.so_state = SS_ISCONNECTING;
2449
2450         for (i = 0; i < V_tcp_syncache.hashsize; i++) {
2451                 sch = &V_tcp_syncache.hashbase[i];
2452                 SCH_LOCK(sch);
2453                 TAILQ_FOREACH(sc, &sch->sch_bucket, sc_hash) {
2454                         if (cr_cansee(req->td->td_ucred, sc->sc_cred) != 0)
2455                                 continue;
2456                         if (sc->sc_inc.inc_flags & INC_ISIPV6)
2457                                 xt.xt_inp.inp_vflag = INP_IPV6;
2458                         else
2459                                 xt.xt_inp.inp_vflag = INP_IPV4;
2460                         bcopy(&sc->sc_inc, &xt.xt_inp.inp_inc,
2461                             sizeof (struct in_conninfo));
2462                         error = SYSCTL_OUT(req, &xt, sizeof xt);
2463                         if (error) {
2464                                 SCH_UNLOCK(sch);
2465                                 return (0);
2466                         }
2467                 }
2468                 SCH_UNLOCK(sch);
2469         }
2470
2471         return (0);
2472 }