net/xfrm/xfrm_replay.c

   1 /*
   2  * xfrm_replay.c - xfrm replay detection, derived from xfrm_state.c.
   3  *
   4  * Copyright (C) 2010 secunet Security Networks AG
   5  * Copyright (C) 2010 Steffen Klassert <steffen.klassert@secunet.com>
   6  *
   7  * This program is free software; you can redistribute it and/or modify it
   8  * under the terms and conditions of the GNU General Public License,
   9  * version 2, as published by the Free Software Foundation.
  10  *
  11  * This program is distributed in the hope it will be useful, but WITHOUT
  12  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  13  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
  14  * more details.
  15  *
  16  * You should have received a copy of the GNU General Public License along with
  17  * this program; if not, write to the Free Software Foundation, Inc.,
  18  * 51 Franklin St - Fifth Floor, Boston, MA 02110-1301 USA.
  19  */
  20
  21 #include <linux/export.h>
  22 #include <net/xfrm.h>
  23
  24 u32 xfrm_replay_seqhi(struct xfrm_state *x, __be32 net_seq)
  25 {
  26         u32 seq, seq_hi, bottom;
  27         struct xfrm_replay_state_esn *replay_esn = x->replay_esn;
  28
  29         if (!(x->props.flags & XFRM_STATE_ESN))
  30                 return 0;
  31
  32         seq = ntohl(net_seq);
  33         seq_hi = replay_esn->seq_hi;
  34         bottom = replay_esn->seq - replay_esn->replay_window + 1;
  35
  36         if (likely(replay_esn->seq >= replay_esn->replay_window - 1)) {
  37                 /* A. same subspace */
  38                 if (unlikely(seq < bottom))
  39                         seq_hi++;
  40         } else {
  41                 /* B. window spans two subspaces */
  42                 if (unlikely(seq >= bottom))
  43                         seq_hi--;
  44         }
  45
  46         return seq_hi;
  47 }
  48 EXPORT_SYMBOL(xfrm_replay_seqhi);
  49 ;
  50 static void xfrm_replay_notify(struct xfrm_state *x, int event)
  51 {
  52         struct km_event c;
  53         /* we send notify messages in case
  54          *  1. we updated on of the sequence numbers, and the seqno difference
  55          *     is at least x->replay_maxdiff, in this case we also update the
  56          *     timeout of our timer function
  57          *  2. if x->replay_maxage has elapsed since last update,
  58          *     and there were changes
  59          *
  60          *  The state structure must be locked!
  61          */
  62
  63         switch (event) {
  64         case XFRM_REPLAY_UPDATE:
  65                 if (!x->replay_maxdiff ||
  66                     ((x->replay.seq - x->preplay.seq < x->replay_maxdiff) &&
  67                     (x->replay.oseq - x->preplay.oseq < x->replay_maxdiff))) {
  68                         if (x->xflags & XFRM_TIME_DEFER)
  69                                 event = XFRM_REPLAY_TIMEOUT;
  70                         else
  71                                 return;
  72                 }
  73
  74                 break;
  75
  76         case XFRM_REPLAY_TIMEOUT:
  77                 if (memcmp(&x->replay, &x->preplay,
  78                            sizeof(struct xfrm_replay_state)) == 0) {
  79                         x->xflags |= XFRM_TIME_DEFER;
  80                         return;
  81                 }
  82
  83                 break;
  84         }
  85
  86         memcpy(&x->preplay, &x->replay, sizeof(struct xfrm_replay_state));
  87         c.event = XFRM_MSG_NEWAE;
  88         c.data.aevent = event;
  89         km_state_notify(x, &c);
  90
  91         if (x->replay_maxage &&
  92             !mod_timer(&x->rtimer, jiffies + x->replay_maxage))
  93                 x->xflags &= ~XFRM_TIME_DEFER;
  94 }
  95
  96 static int xfrm_replay_overflow(struct xfrm_state *x, struct sk_buff *skb)
  97 {
  98         int err = 0;
  99         struct net *net = xs_net(x);
 100
 101         if (x->type->flags & XFRM_TYPE_REPLAY_PROT) {
 102                 XFRM_SKB_CB(skb)->seq.output.low = ++x->replay.oseq;
 103                 XFRM_SKB_CB(skb)->seq.output.hi = 0;
 104                 if (unlikely(x->replay.oseq == 0)) {
 105                         x->replay.oseq--;
 106                         xfrm_audit_state_replay_overflow(x, skb);
 107                         err = -EOVERFLOW;
 108
 109                         return err;
 110                 }
 111                 if (xfrm_aevent_is_on(net))
 112                         x->repl->notify(x, XFRM_REPLAY_UPDATE);
 113         }
 114
 115         return err;
 116 }
 117
 118 static int xfrm_replay_check(struct xfrm_state *x,
 119                       struct sk_buff *skb, __be32 net_seq)
 120 {
 121         u32 diff;
 122         u32 seq = ntohl(net_seq);
 123
 124         if (!x->props.replay_window)
 125                 return 0;
 126
 127         if (unlikely(seq == 0))
 128                 goto err;
 129
 130         if (likely(seq > x->replay.seq))
 131                 return 0;
 132
 133         diff = x->replay.seq - seq;
 134         if (diff >= x->props.replay_window) {
 135                 x->stats.replay_window++;
 136                 goto err;
 137         }
 138
 139         if (x->replay.bitmap & (1U << diff)) {
 140                 x->stats.replay++;
 141                 goto err;
 142         }
 143         return 0;
 144
 145 err:
 146         xfrm_audit_state_replay(x, skb, net_seq);
 147         return -EINVAL;
 148 }
 149
 150 static void xfrm_replay_advance(struct xfrm_state *x, __be32 net_seq)
 151 {
 152         u32 diff;
 153         u32 seq = ntohl(net_seq);
 154
 155         if (!x->props.replay_window)
 156                 return;
 157
 158         if (seq > x->replay.seq) {
 159                 diff = seq - x->replay.seq;
 160                 if (diff < x->props.replay_window)
 161                         x->replay.bitmap = ((x->replay.bitmap) << diff) | 1;
 162                 else
 163                         x->replay.bitmap = 1;
 164                 x->replay.seq = seq;
 165         } else {
 166                 diff = x->replay.seq - seq;
 167                 x->replay.bitmap |= (1U << diff);
 168         }
 169
 170         if (xfrm_aevent_is_on(xs_net(x)))
 171                 x->repl->notify(x, XFRM_REPLAY_UPDATE);
 172 }
 173
 174 static int xfrm_replay_overflow_bmp(struct xfrm_state *x, struct sk_buff *skb)
 175 {
 176         int err = 0;
 177         struct xfrm_replay_state_esn *replay_esn = x->replay_esn;
 178         struct net *net = xs_net(x);
 179
 180         if (x->type->flags & XFRM_TYPE_REPLAY_PROT) {
 181                 XFRM_SKB_CB(skb)->seq.output.low = ++replay_esn->oseq;
 182                 XFRM_SKB_CB(skb)->seq.output.hi = 0;
 183                 if (unlikely(replay_esn->oseq == 0)) {
 184                         replay_esn->oseq--;
 185                         xfrm_audit_state_replay_overflow(x, skb);
 186                         err = -EOVERFLOW;
 187
 188                         return err;
 189                 }
 190                 if (xfrm_aevent_is_on(net))
 191                         x->repl->notify(x, XFRM_REPLAY_UPDATE);
 192         }
 193
 194         return err;
 195 }
 196
 197 static int xfrm_replay_check_bmp(struct xfrm_state *x,
 198                                  struct sk_buff *skb, __be32 net_seq)
 199 {
 200         unsigned int bitnr, nr;
 201         struct xfrm_replay_state_esn *replay_esn = x->replay_esn;
 202         u32 pos;
 203         u32 seq = ntohl(net_seq);
 204         u32 diff =  replay_esn->seq - seq;
 205
 206         if (!replay_esn->replay_window)
 207                 return 0;
 208
 209         if (unlikely(seq == 0))
 210                 goto err;
 211
 212         if (likely(seq > replay_esn->seq))
 213                 return 0;
 214
 215         if (diff >= replay_esn->replay_window) {
 216                 x->stats.replay_window++;
 217                 goto err;
 218         }
 219
 220         pos = (replay_esn->seq - 1) % replay_esn->replay_window;
 221
 222         if (pos >= diff)
 223                 bitnr = (pos - diff) % replay_esn->replay_window;
 224         else
 225                 bitnr = replay_esn->replay_window - (diff - pos);
 226
 227         nr = bitnr >> 5;
 228         bitnr = bitnr & 0x1F;
 229         if (replay_esn->bmp[nr] & (1U << bitnr))
 230                 goto err_replay;
 231
 232         return 0;
 233
 234 err_replay:
 235         x->stats.replay++;
 236 err:
 237         xfrm_audit_state_replay(x, skb, net_seq);
 238         return -EINVAL;
 239 }
 240
 241 static void xfrm_replay_advance_bmp(struct xfrm_state *x, __be32 net_seq)
 242 {
 243         unsigned int bitnr, nr, i;
 244         u32 diff;
 245         struct xfrm_replay_state_esn *replay_esn = x->replay_esn;
 246         u32 seq = ntohl(net_seq);
 247         u32 pos;
 248
 249         if (!replay_esn->replay_window)
 250                 return;
 251
 252         pos = (replay_esn->seq - 1) % replay_esn->replay_window;
 253
 254         if (seq > replay_esn->seq) {
 255                 diff = seq - replay_esn->seq;
 256
 257                 if (diff < replay_esn->replay_window) {
 258                         for (i = 1; i < diff; i++) {
 259                                 bitnr = (pos + i) % replay_esn->replay_window;
 260                                 nr = bitnr >> 5;
 261                                 bitnr = bitnr & 0x1F;
 262                                 replay_esn->bmp[nr] &=  ~(1U << bitnr);
 263                         }
 264                 } else {
 265                         nr = (replay_esn->replay_window - 1) >> 5;
 266                         for (i = 0; i <= nr; i++)
 267                                 replay_esn->bmp[i] = 0;
 268                 }
 269
 270                 bitnr = (pos + diff) % replay_esn->replay_window;
 271                 replay_esn->seq = seq;
 272         } else {
 273                 diff = replay_esn->seq - seq;
 274
 275                 if (pos >= diff)
 276                         bitnr = (pos - diff) % replay_esn->replay_window;
 277                 else
 278                         bitnr = replay_esn->replay_window - (diff - pos);
 279         }
 280
 281         nr = bitnr >> 5;
 282         bitnr = bitnr & 0x1F;
 283         replay_esn->bmp[nr] |= (1U << bitnr);
 284
 285         if (xfrm_aevent_is_on(xs_net(x)))
 286                 x->repl->notify(x, XFRM_REPLAY_UPDATE);
 287 }
 288
 289 static void xfrm_replay_notify_bmp(struct xfrm_state *x, int event)
 290 {
 291         struct km_event c;
 292         struct xfrm_replay_state_esn *replay_esn = x->replay_esn;
 293         struct xfrm_replay_state_esn *preplay_esn = x->preplay_esn;
 294
 295         /* we send notify messages in case
 296          *  1. we updated on of the sequence numbers, and the seqno difference
 297          *     is at least x->replay_maxdiff, in this case we also update the
 298          *     timeout of our timer function
 299          *  2. if x->replay_maxage has elapsed since last update,
 300          *     and there were changes
 301          *
 302          *  The state structure must be locked!
 303          */
 304
 305         switch (event) {
 306         case XFRM_REPLAY_UPDATE:
 307                 if (!x->replay_maxdiff ||
 308                     ((replay_esn->seq - preplay_esn->seq < x->replay_maxdiff) &&
 309                     (replay_esn->oseq - preplay_esn->oseq
 310                      < x->replay_maxdiff))) {
 311                         if (x->xflags & XFRM_TIME_DEFER)
 312                                 event = XFRM_REPLAY_TIMEOUT;
 313                         else
 314                                 return;
 315                 }
 316
 317                 break;
 318
 319         case XFRM_REPLAY_TIMEOUT:
 320                 if (memcmp(x->replay_esn, x->preplay_esn,
 321                            xfrm_replay_state_esn_len(replay_esn)) == 0) {
 322                         x->xflags |= XFRM_TIME_DEFER;
 323                         return;
 324                 }
 325
 326                 break;
 327         }
 328
 329         memcpy(x->preplay_esn, x->replay_esn,
 330                xfrm_replay_state_esn_len(replay_esn));
 331         c.event = XFRM_MSG_NEWAE;
 332         c.data.aevent = event;
 333         km_state_notify(x, &c);
 334
 335         if (x->replay_maxage &&
 336             !mod_timer(&x->rtimer, jiffies + x->replay_maxage))
 337                 x->xflags &= ~XFRM_TIME_DEFER;
 338 }
 339
 340 static void xfrm_replay_notify_esn(struct xfrm_state *x, int event)
 341 {
 342         u32 seq_diff, oseq_diff;
 343         struct km_event c;
 344         struct xfrm_replay_state_esn *replay_esn = x->replay_esn;
 345         struct xfrm_replay_state_esn *preplay_esn = x->preplay_esn;
 346
 347         /* we send notify messages in case
 348          *  1. we updated on of the sequence numbers, and the seqno difference
 349          *     is at least x->replay_maxdiff, in this case we also update the
 350          *     timeout of our timer function
 351          *  2. if x->replay_maxage has elapsed since last update,
 352          *     and there were changes
 353          *
 354          *  The state structure must be locked!
 355          */
 356
 357         switch (event) {
 358         case XFRM_REPLAY_UPDATE:
 359                 if (x->replay_maxdiff) {
 360                         if (replay_esn->seq_hi == preplay_esn->seq_hi)
 361                                 seq_diff = replay_esn->seq - preplay_esn->seq;
 362                         else
 363                                 seq_diff = ~preplay_esn->seq + replay_esn->seq
 364                                            + 1;
 365
 366                         if (replay_esn->oseq_hi == preplay_esn->oseq_hi)
 367                                 oseq_diff = replay_esn->oseq
 368                                             - preplay_esn->oseq;
 369                         else
 370                                 oseq_diff = ~preplay_esn->oseq
 371                                             + replay_esn->oseq + 1;
 372
 373                         if (seq_diff >= x->replay_maxdiff ||
 374                             oseq_diff >= x->replay_maxdiff)
 375                                 break;
 376                 }
 377
 378                 if (x->xflags & XFRM_TIME_DEFER)
 379                         event = XFRM_REPLAY_TIMEOUT;
 380                 else
 381                         return;
 382
 383                 break;
 384
 385         case XFRM_REPLAY_TIMEOUT:
 386                 if (memcmp(x->replay_esn, x->preplay_esn,
 387                            xfrm_replay_state_esn_len(replay_esn)) == 0) {
 388                         x->xflags |= XFRM_TIME_DEFER;
 389                         return;
 390                 }
 391
 392                 break;
 393         }
 394
 395         memcpy(x->preplay_esn, x->replay_esn,
 396                xfrm_replay_state_esn_len(replay_esn));
 397         c.event = XFRM_MSG_NEWAE;
 398         c.data.aevent = event;
 399         km_state_notify(x, &c);
 400
 401         if (x->replay_maxage &&
 402             !mod_timer(&x->rtimer, jiffies + x->replay_maxage))
 403                 x->xflags &= ~XFRM_TIME_DEFER;
 404 }
 405
 406 static int xfrm_replay_overflow_esn(struct xfrm_state *x, struct sk_buff *skb)
 407 {
 408         int err = 0;
 409         struct xfrm_replay_state_esn *replay_esn = x->replay_esn;
 410         struct net *net = xs_net(x);
 411
 412         if (x->type->flags & XFRM_TYPE_REPLAY_PROT) {
 413                 XFRM_SKB_CB(skb)->seq.output.low = ++replay_esn->oseq;
 414                 XFRM_SKB_CB(skb)->seq.output.hi = replay_esn->oseq_hi;
 415
 416                 if (unlikely(replay_esn->oseq == 0)) {
 417                         XFRM_SKB_CB(skb)->seq.output.hi = ++replay_esn->oseq_hi;
 418
 419                         if (replay_esn->oseq_hi == 0) {
 420                                 replay_esn->oseq--;
 421                                 replay_esn->oseq_hi--;
 422                                 xfrm_audit_state_replay_overflow(x, skb);
 423                                 err = -EOVERFLOW;
 424
 425                                 return err;
 426                         }
 427                 }
 428                 if (xfrm_aevent_is_on(net))
 429                         x->repl->notify(x, XFRM_REPLAY_UPDATE);
 430         }
 431
 432         return err;
 433 }
 434
 435 static int xfrm_replay_check_esn(struct xfrm_state *x,
 436                                  struct sk_buff *skb, __be32 net_seq)
 437 {
 438         unsigned int bitnr, nr;
 439         u32 diff;
 440         struct xfrm_replay_state_esn *replay_esn = x->replay_esn;
 441         u32 pos;
 442         u32 seq = ntohl(net_seq);
 443         u32 wsize = replay_esn->replay_window;
 444         u32 top = replay_esn->seq;
 445         u32 bottom = top - wsize + 1;
 446
 447         if (!wsize)
 448                 return 0;
 449
 450         if (unlikely(seq == 0 && replay_esn->seq_hi == 0 &&
 451                      (replay_esn->seq < replay_esn->replay_window - 1)))
 452                 goto err;
 453
 454         diff = top - seq;
 455
 456         if (likely(top >= wsize - 1)) {
 457                 /* A. same subspace */
 458                 if (likely(seq > top) || seq < bottom)
 459                         return 0;
 460         } else {
 461                 /* B. window spans two subspaces */
 462                 if (likely(seq > top && seq < bottom))
 463                         return 0;
 464                 if (seq >= bottom)
 465                         diff = ~seq + top + 1;
 466         }
 467
 468         if (diff >= replay_esn->replay_window) {
 469                 x->stats.replay_window++;
 470                 goto err;
 471         }
 472
 473         pos = (replay_esn->seq - 1) % replay_esn->replay_window;
 474
 475         if (pos >= diff)
 476                 bitnr = (pos - diff) % replay_esn->replay_window;
 477         else
 478                 bitnr = replay_esn->replay_window - (diff - pos);
 479
 480         nr = bitnr >> 5;
 481         bitnr = bitnr & 0x1F;
 482         if (replay_esn->bmp[nr] & (1U << bitnr))
 483                 goto err_replay;
 484
 485         return 0;
 486
 487 err_replay:
 488         x->stats.replay++;
 489 err:
 490         xfrm_audit_state_replay(x, skb, net_seq);
 491         return -EINVAL;
 492 }
 493
 494 static int xfrm_replay_recheck_esn(struct xfrm_state *x,
 495                                    struct sk_buff *skb, __be32 net_seq)
 496 {
 497         if (unlikely(XFRM_SKB_CB(skb)->seq.input.hi !=
 498                      htonl(xfrm_replay_seqhi(x, net_seq)))) {
 499                         x->stats.replay_window++;
 500                         return -EINVAL;
 501         }
 502
 503         return xfrm_replay_check_esn(x, skb, net_seq);
 504 }
 505
 506 static void xfrm_replay_advance_esn(struct xfrm_state *x, __be32 net_seq)
 507 {
 508         unsigned int bitnr, nr, i;
 509         int wrap;
 510         u32 diff, pos, seq, seq_hi;
 511         struct xfrm_replay_state_esn *replay_esn = x->replay_esn;
 512
 513         if (!replay_esn->replay_window)
 514                 return;
 515
 516         seq = ntohl(net_seq);
 517         pos = (replay_esn->seq - 1) % replay_esn->replay_window;
 518         seq_hi = xfrm_replay_seqhi(x, net_seq);
 519         wrap = seq_hi - replay_esn->seq_hi;
 520
 521         if ((!wrap && seq > replay_esn->seq) || wrap > 0) {
 522                 if (likely(!wrap))
 523                         diff = seq - replay_esn->seq;
 524                 else
 525                         diff = ~replay_esn->seq + seq + 1;
 526
 527                 if (diff < replay_esn->replay_window) {
 528                         for (i = 1; i < diff; i++) {
 529                                 bitnr = (pos + i) % replay_esn->replay_window;
 530                                 nr = bitnr >> 5;
 531                                 bitnr = bitnr & 0x1F;
 532                                 replay_esn->bmp[nr] &=  ~(1U << bitnr);
 533                         }
 534                 } else {
 535                         nr = (replay_esn->replay_window - 1) >> 5;
 536                         for (i = 0; i <= nr; i++)
 537                                 replay_esn->bmp[i] = 0;
 538                 }
 539
 540                 bitnr = (pos + diff) % replay_esn->replay_window;
 541                 replay_esn->seq = seq;
 542
 543                 if (unlikely(wrap > 0))
 544                         replay_esn->seq_hi++;
 545         } else {
 546                 diff = replay_esn->seq - seq;
 547
 548                 if (pos >= diff)
 549                         bitnr = (pos - diff) % replay_esn->replay_window;
 550                 else
 551                         bitnr = replay_esn->replay_window - (diff - pos);
 552         }
 553
 554         nr = bitnr >> 5;
 555         bitnr = bitnr & 0x1F;
 556         replay_esn->bmp[nr] |= (1U << bitnr);
 557
 558         if (xfrm_aevent_is_on(xs_net(x)))
 559                 x->repl->notify(x, XFRM_REPLAY_UPDATE);
 560 }
 561
 562 #ifdef CONFIG_XFRM_OFFLOAD
 563 static int xfrm_replay_overflow_offload(struct xfrm_state *x, struct sk_buff *skb)
 564 {
 565         int err = 0;
 566         struct net *net = xs_net(x);
 567         struct xfrm_offload *xo = xfrm_offload(skb);
 568         __u32 oseq = x->replay.oseq;
 569
 570         if (!xo)
 571                 return xfrm_replay_overflow(x, skb);
 572
 573         if (x->type->flags & XFRM_TYPE_REPLAY_PROT) {
 574                 if (!skb_is_gso(skb)) {
 575                         XFRM_SKB_CB(skb)->seq.output.low = ++oseq;
 576                         xo->seq.low = oseq;
 577                 } else {
 578                         XFRM_SKB_CB(skb)->seq.output.low = oseq + 1;
 579                         xo->seq.low = oseq + 1;
 580                         oseq += skb_shinfo(skb)->gso_segs;
 581                 }
 582
 583                 XFRM_SKB_CB(skb)->seq.output.hi = 0;
 584                 xo->seq.hi = 0;
 585                 if (unlikely(oseq < x->replay.oseq)) {
 586                         xfrm_audit_state_replay_overflow(x, skb);
 587                         err = -EOVERFLOW;
 588
 589                         return err;
 590                 }
 591
 592                 x->replay.oseq = oseq;
 593
 594                 if (xfrm_aevent_is_on(net))
 595                         x->repl->notify(x, XFRM_REPLAY_UPDATE);
 596         }
 597
 598         return err;
 599 }
 600
 601 static int xfrm_replay_overflow_offload_bmp(struct xfrm_state *x, struct sk_buff *skb)
 602 {
 603         int err = 0;
 604         struct xfrm_offload *xo = xfrm_offload(skb);
 605         struct xfrm_replay_state_esn *replay_esn = x->replay_esn;
 606         struct net *net = xs_net(x);
 607         __u32 oseq = replay_esn->oseq;
 608
 609         if (!xo)
 610                 return xfrm_replay_overflow_bmp(x, skb);
 611
 612         if (x->type->flags & XFRM_TYPE_REPLAY_PROT) {
 613                 if (!skb_is_gso(skb)) {
 614                         XFRM_SKB_CB(skb)->seq.output.low = ++oseq;
 615                         xo->seq.low = oseq;
 616                 } else {
 617                         XFRM_SKB_CB(skb)->seq.output.low = oseq + 1;
 618                         xo->seq.low = oseq + 1;
 619                         oseq += skb_shinfo(skb)->gso_segs;
 620                 }
 621
 622                 XFRM_SKB_CB(skb)->seq.output.hi = 0;
 623                 xo->seq.hi = 0;
 624                 if (unlikely(oseq < replay_esn->oseq)) {
 625                         xfrm_audit_state_replay_overflow(x, skb);
 626                         err = -EOVERFLOW;
 627
 628                         return err;
 629                 } else {
 630                         replay_esn->oseq = oseq;
 631                 }
 632
 633                 if (xfrm_aevent_is_on(net))
 634                         x->repl->notify(x, XFRM_REPLAY_UPDATE);
 635         }
 636
 637         return err;
 638 }
 639
 640 static int xfrm_replay_overflow_offload_esn(struct xfrm_state *x, struct sk_buff *skb)
 641 {
 642         int err = 0;
 643         struct xfrm_offload *xo = xfrm_offload(skb);
 644         struct xfrm_replay_state_esn *replay_esn = x->replay_esn;
 645         struct net *net = xs_net(x);
 646         __u32 oseq = replay_esn->oseq;
 647         __u32 oseq_hi = replay_esn->oseq_hi;
 648
 649         if (!xo)
 650                 return xfrm_replay_overflow_esn(x, skb);
 651
 652         if (x->type->flags & XFRM_TYPE_REPLAY_PROT) {
 653                 if (!skb_is_gso(skb)) {
 654                         XFRM_SKB_CB(skb)->seq.output.low = ++oseq;
 655                         XFRM_SKB_CB(skb)->seq.output.hi = oseq_hi;
 656                         xo->seq.low = oseq;
 657                         xo->seq.hi = oseq_hi;
 658                 } else {
 659                         XFRM_SKB_CB(skb)->seq.output.low = oseq + 1;
 660                         XFRM_SKB_CB(skb)->seq.output.hi = oseq_hi;
 661                         xo->seq.low = oseq = oseq + 1;
 662                         xo->seq.hi = oseq_hi;
 663                         oseq += skb_shinfo(skb)->gso_segs;
 664                 }
 665
 666                 if (unlikely(oseq < replay_esn->oseq)) {
 667                         XFRM_SKB_CB(skb)->seq.output.hi = ++oseq_hi;
 668                         xo->seq.hi = oseq_hi;
 669
 670                         if (replay_esn->oseq_hi == 0) {
 671                                 replay_esn->oseq--;
 672                                 replay_esn->oseq_hi--;
 673                                 xfrm_audit_state_replay_overflow(x, skb);
 674                                 err = -EOVERFLOW;
 675
 676                                 return err;
 677                         }
 678                 }
 679
 680                 replay_esn->oseq = oseq;
 681                 replay_esn->oseq_hi = oseq_hi;
 682
 683                 if (xfrm_aevent_is_on(net))
 684                         x->repl->notify(x, XFRM_REPLAY_UPDATE);
 685         }
 686
 687         return err;
 688 }
 689
 690 static const struct xfrm_replay xfrm_replay_legacy = {
 691         .advance        = xfrm_replay_advance,
 692         .check          = xfrm_replay_check,
 693         .recheck        = xfrm_replay_check,
 694         .notify         = xfrm_replay_notify,
 695         .overflow       = xfrm_replay_overflow_offload,
 696 };
 697
 698 static const struct xfrm_replay xfrm_replay_bmp = {
 699         .advance        = xfrm_replay_advance_bmp,
 700         .check          = xfrm_replay_check_bmp,
 701         .recheck        = xfrm_replay_check_bmp,
 702         .notify         = xfrm_replay_notify_bmp,
 703         .overflow       = xfrm_replay_overflow_offload_bmp,
 704 };
 705
 706 static const struct xfrm_replay xfrm_replay_esn = {
 707         .advance        = xfrm_replay_advance_esn,
 708         .check          = xfrm_replay_check_esn,
 709         .recheck        = xfrm_replay_recheck_esn,
 710         .notify         = xfrm_replay_notify_esn,
 711         .overflow       = xfrm_replay_overflow_offload_esn,
 712 };
 713 #else
 714 static const struct xfrm_replay xfrm_replay_legacy = {
 715         .advance        = xfrm_replay_advance,
 716         .check          = xfrm_replay_check,
 717         .recheck        = xfrm_replay_check,
 718         .notify         = xfrm_replay_notify,
 719         .overflow       = xfrm_replay_overflow,
 720 };
 721
 722 static const struct xfrm_replay xfrm_replay_bmp = {
 723         .advance        = xfrm_replay_advance_bmp,
 724         .check          = xfrm_replay_check_bmp,
 725         .recheck        = xfrm_replay_check_bmp,
 726         .notify         = xfrm_replay_notify_bmp,
 727         .overflow       = xfrm_replay_overflow_bmp,
 728 };
 729
 730 static const struct xfrm_replay xfrm_replay_esn = {
 731         .advance        = xfrm_replay_advance_esn,
 732         .check          = xfrm_replay_check_esn,
 733         .recheck        = xfrm_replay_recheck_esn,
 734         .notify         = xfrm_replay_notify_esn,
 735         .overflow       = xfrm_replay_overflow_esn,
 736 };
 737 #endif
 738
 739 int xfrm_init_replay(struct xfrm_state *x)
 740 {
 741         struct xfrm_replay_state_esn *replay_esn = x->replay_esn;
 742
 743         if (replay_esn) {
 744                 if (replay_esn->replay_window >
 745                     replay_esn->bmp_len * sizeof(__u32) * 8)
 746                         return -EINVAL;
 747
 748                 if (x->props.flags & XFRM_STATE_ESN) {
 749                         if (replay_esn->replay_window == 0)
 750                                 return -EINVAL;
 751                         x->repl = &xfrm_replay_esn;
 752                 } else {
 753                         x->repl = &xfrm_replay_bmp;
 754                 }
 755         } else {
 756                 x->repl = &xfrm_replay_legacy;
 757         }
 758
 759         return 0;
 760 }
 761 EXPORT_SYMBOL(xfrm_init_replay);