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 xfrm_dev_state_advance_esn(x); 555 556 nr = bitnr >> 5; 557 bitnr = bitnr & 0x1F; 558 replay_esn->bmp[nr] |= (1U << bitnr); 559 560 if (xfrm_aevent_is_on(xs_net(x))) 561 x->repl->notify(x, XFRM_REPLAY_UPDATE); 562 } 563 564 #ifdef CONFIG_XFRM_OFFLOAD 565 static int xfrm_replay_overflow_offload(struct xfrm_state *x, struct sk_buff *skb) 566 { 567 int err = 0; 568 struct net *net = xs_net(x); 569 struct xfrm_offload *xo = xfrm_offload(skb); 570 __u32 oseq = x->replay.oseq; 571 572 if (!xo) 573 return xfrm_replay_overflow(x, skb); 574 575 if (x->type->flags & XFRM_TYPE_REPLAY_PROT) { 576 if (!skb_is_gso(skb)) { 577 XFRM_SKB_CB(skb)->seq.output.low = ++oseq; 578 xo->seq.low = oseq; 579 } else { 580 XFRM_SKB_CB(skb)->seq.output.low = oseq + 1; 581 xo->seq.low = oseq + 1; 582 oseq += skb_shinfo(skb)->gso_segs; 583 } 584 585 XFRM_SKB_CB(skb)->seq.output.hi = 0; 586 xo->seq.hi = 0; 587 if (unlikely(oseq < x->replay.oseq)) { 588 xfrm_audit_state_replay_overflow(x, skb); 589 err = -EOVERFLOW; 590 591 return err; 592 } 593 594 x->replay.oseq = oseq; 595 596 if (xfrm_aevent_is_on(net)) 597 x->repl->notify(x, XFRM_REPLAY_UPDATE); 598 } 599 600 return err; 601 } 602 603 static int xfrm_replay_overflow_offload_bmp(struct xfrm_state *x, struct sk_buff *skb) 604 { 605 int err = 0; 606 struct xfrm_offload *xo = xfrm_offload(skb); 607 struct xfrm_replay_state_esn *replay_esn = x->replay_esn; 608 struct net *net = xs_net(x); 609 __u32 oseq = replay_esn->oseq; 610 611 if (!xo) 612 return xfrm_replay_overflow_bmp(x, skb); 613 614 if (x->type->flags & XFRM_TYPE_REPLAY_PROT) { 615 if (!skb_is_gso(skb)) { 616 XFRM_SKB_CB(skb)->seq.output.low = ++oseq; 617 xo->seq.low = oseq; 618 } else { 619 XFRM_SKB_CB(skb)->seq.output.low = oseq + 1; 620 xo->seq.low = oseq + 1; 621 oseq += skb_shinfo(skb)->gso_segs; 622 } 623 624 XFRM_SKB_CB(skb)->seq.output.hi = 0; 625 xo->seq.hi = 0; 626 if (unlikely(oseq < replay_esn->oseq)) { 627 xfrm_audit_state_replay_overflow(x, skb); 628 err = -EOVERFLOW; 629 630 return err; 631 } else { 632 replay_esn->oseq = oseq; 633 } 634 635 if (xfrm_aevent_is_on(net)) 636 x->repl->notify(x, XFRM_REPLAY_UPDATE); 637 } 638 639 return err; 640 } 641 642 static int xfrm_replay_overflow_offload_esn(struct xfrm_state *x, struct sk_buff *skb) 643 { 644 int err = 0; 645 struct xfrm_offload *xo = xfrm_offload(skb); 646 struct xfrm_replay_state_esn *replay_esn = x->replay_esn; 647 struct net *net = xs_net(x); 648 __u32 oseq = replay_esn->oseq; 649 __u32 oseq_hi = replay_esn->oseq_hi; 650 651 if (!xo) 652 return xfrm_replay_overflow_esn(x, skb); 653 654 if (x->type->flags & XFRM_TYPE_REPLAY_PROT) { 655 if (!skb_is_gso(skb)) { 656 XFRM_SKB_CB(skb)->seq.output.low = ++oseq; 657 XFRM_SKB_CB(skb)->seq.output.hi = oseq_hi; 658 xo->seq.low = oseq; 659 xo->seq.hi = oseq_hi; 660 } else { 661 XFRM_SKB_CB(skb)->seq.output.low = oseq + 1; 662 XFRM_SKB_CB(skb)->seq.output.hi = oseq_hi; 663 xo->seq.low = oseq + 1; 664 xo->seq.hi = oseq_hi; 665 oseq += skb_shinfo(skb)->gso_segs; 666 } 667 668 if (unlikely(oseq < replay_esn->oseq)) { 669 XFRM_SKB_CB(skb)->seq.output.hi = ++oseq_hi; 670 xo->seq.hi = oseq_hi; 671 replay_esn->oseq_hi = oseq_hi; 672 if (replay_esn->oseq_hi == 0) { 673 replay_esn->oseq--; 674 replay_esn->oseq_hi--; 675 xfrm_audit_state_replay_overflow(x, skb); 676 err = -EOVERFLOW; 677 678 return err; 679 } 680 } 681 682 replay_esn->oseq = oseq; 683 684 if (xfrm_aevent_is_on(net)) 685 x->repl->notify(x, XFRM_REPLAY_UPDATE); 686 } 687 688 return err; 689 } 690 691 static const struct xfrm_replay xfrm_replay_legacy = { 692 .advance = xfrm_replay_advance, 693 .check = xfrm_replay_check, 694 .recheck = xfrm_replay_check, 695 .notify = xfrm_replay_notify, 696 .overflow = xfrm_replay_overflow_offload, 697 }; 698 699 static const struct xfrm_replay xfrm_replay_bmp = { 700 .advance = xfrm_replay_advance_bmp, 701 .check = xfrm_replay_check_bmp, 702 .recheck = xfrm_replay_check_bmp, 703 .notify = xfrm_replay_notify_bmp, 704 .overflow = xfrm_replay_overflow_offload_bmp, 705 }; 706 707 static const struct xfrm_replay xfrm_replay_esn = { 708 .advance = xfrm_replay_advance_esn, 709 .check = xfrm_replay_check_esn, 710 .recheck = xfrm_replay_recheck_esn, 711 .notify = xfrm_replay_notify_esn, 712 .overflow = xfrm_replay_overflow_offload_esn, 713 }; 714 #else 715 static const struct xfrm_replay xfrm_replay_legacy = { 716 .advance = xfrm_replay_advance, 717 .check = xfrm_replay_check, 718 .recheck = xfrm_replay_check, 719 .notify = xfrm_replay_notify, 720 .overflow = xfrm_replay_overflow, 721 }; 722 723 static const struct xfrm_replay xfrm_replay_bmp = { 724 .advance = xfrm_replay_advance_bmp, 725 .check = xfrm_replay_check_bmp, 726 .recheck = xfrm_replay_check_bmp, 727 .notify = xfrm_replay_notify_bmp, 728 .overflow = xfrm_replay_overflow_bmp, 729 }; 730 731 static const struct xfrm_replay xfrm_replay_esn = { 732 .advance = xfrm_replay_advance_esn, 733 .check = xfrm_replay_check_esn, 734 .recheck = xfrm_replay_recheck_esn, 735 .notify = xfrm_replay_notify_esn, 736 .overflow = xfrm_replay_overflow_esn, 737 }; 738 #endif 739 740 int xfrm_init_replay(struct xfrm_state *x) 741 { 742 struct xfrm_replay_state_esn *replay_esn = x->replay_esn; 743 744 if (replay_esn) { 745 if (replay_esn->replay_window > 746 replay_esn->bmp_len * sizeof(__u32) * 8) 747 return -EINVAL; 748 749 if (x->props.flags & XFRM_STATE_ESN) { 750 if (replay_esn->replay_window == 0) 751 return -EINVAL; 752 x->repl = &xfrm_replay_esn; 753 } else { 754 x->repl = &xfrm_replay_bmp; 755 } 756 } else { 757 x->repl = &xfrm_replay_legacy; 758 } 759 760 return 0; 761 } 762 EXPORT_SYMBOL(xfrm_init_replay); 763