1 // SPDX-License-Identifier: GPL-2.0-or-later 2 /* 3 * Copyright (C)2002 USAGI/WIDE Project 4 * 5 * Authors 6 * 7 * Mitsuru KANDA @USAGI : IPv6 Support 8 * Kazunori MIYAZAWA @USAGI : 9 * Kunihiro Ishiguro <kunihiro@ipinfusion.com> 10 * 11 * This file is derived from net/ipv4/esp.c 12 */ 13 14 #define pr_fmt(fmt) "IPv6: " fmt 15 16 #include <crypto/aead.h> 17 #include <crypto/authenc.h> 18 #include <linux/err.h> 19 #include <linux/module.h> 20 #include <net/ip.h> 21 #include <net/xfrm.h> 22 #include <net/esp.h> 23 #include <linux/scatterlist.h> 24 #include <linux/kernel.h> 25 #include <linux/pfkeyv2.h> 26 #include <linux/random.h> 27 #include <linux/slab.h> 28 #include <linux/spinlock.h> 29 #include <net/ip6_route.h> 30 #include <net/icmp.h> 31 #include <net/ipv6.h> 32 #include <net/protocol.h> 33 #include <linux/icmpv6.h> 34 35 #include <linux/highmem.h> 36 37 struct esp_skb_cb { 38 struct xfrm_skb_cb xfrm; 39 void *tmp; 40 }; 41 42 #define ESP_SKB_CB(__skb) ((struct esp_skb_cb *)&((__skb)->cb[0])) 43 44 /* 45 * Allocate an AEAD request structure with extra space for SG and IV. 46 * 47 * For alignment considerations the upper 32 bits of the sequence number are 48 * placed at the front, if present. Followed by the IV, the request and finally 49 * the SG list. 50 * 51 * TODO: Use spare space in skb for this where possible. 52 */ 53 static void *esp_alloc_tmp(struct crypto_aead *aead, int nfrags, int seqihlen) 54 { 55 unsigned int len; 56 57 len = seqihlen; 58 59 len += crypto_aead_ivsize(aead); 60 61 if (len) { 62 len += crypto_aead_alignmask(aead) & 63 ~(crypto_tfm_ctx_alignment() - 1); 64 len = ALIGN(len, crypto_tfm_ctx_alignment()); 65 } 66 67 len += sizeof(struct aead_request) + crypto_aead_reqsize(aead); 68 len = ALIGN(len, __alignof__(struct scatterlist)); 69 70 len += sizeof(struct scatterlist) * nfrags; 71 72 return kmalloc(len, GFP_ATOMIC); 73 } 74 75 static inline __be32 *esp_tmp_seqhi(void *tmp) 76 { 77 return PTR_ALIGN((__be32 *)tmp, __alignof__(__be32)); 78 } 79 80 static inline u8 *esp_tmp_iv(struct crypto_aead *aead, void *tmp, int seqhilen) 81 { 82 return crypto_aead_ivsize(aead) ? 83 PTR_ALIGN((u8 *)tmp + seqhilen, 84 crypto_aead_alignmask(aead) + 1) : tmp + seqhilen; 85 } 86 87 static inline struct aead_request *esp_tmp_req(struct crypto_aead *aead, u8 *iv) 88 { 89 struct aead_request *req; 90 91 req = (void *)PTR_ALIGN(iv + crypto_aead_ivsize(aead), 92 crypto_tfm_ctx_alignment()); 93 aead_request_set_tfm(req, aead); 94 return req; 95 } 96 97 static inline struct scatterlist *esp_req_sg(struct crypto_aead *aead, 98 struct aead_request *req) 99 { 100 return (void *)ALIGN((unsigned long)(req + 1) + 101 crypto_aead_reqsize(aead), 102 __alignof__(struct scatterlist)); 103 } 104 105 static void esp_ssg_unref(struct xfrm_state *x, void *tmp) 106 { 107 struct crypto_aead *aead = x->data; 108 int seqhilen = 0; 109 u8 *iv; 110 struct aead_request *req; 111 struct scatterlist *sg; 112 113 if (x->props.flags & XFRM_STATE_ESN) 114 seqhilen += sizeof(__be32); 115 116 iv = esp_tmp_iv(aead, tmp, seqhilen); 117 req = esp_tmp_req(aead, iv); 118 119 /* Unref skb_frag_pages in the src scatterlist if necessary. 120 * Skip the first sg which comes from skb->data. 121 */ 122 if (req->src != req->dst) 123 for (sg = sg_next(req->src); sg; sg = sg_next(sg)) 124 put_page(sg_page(sg)); 125 } 126 127 static void esp_output_done(struct crypto_async_request *base, int err) 128 { 129 struct sk_buff *skb = base->data; 130 struct xfrm_offload *xo = xfrm_offload(skb); 131 void *tmp; 132 struct xfrm_state *x; 133 134 if (xo && (xo->flags & XFRM_DEV_RESUME)) { 135 struct sec_path *sp = skb_sec_path(skb); 136 137 x = sp->xvec[sp->len - 1]; 138 } else { 139 x = skb_dst(skb)->xfrm; 140 } 141 142 tmp = ESP_SKB_CB(skb)->tmp; 143 esp_ssg_unref(x, tmp); 144 kfree(tmp); 145 146 if (xo && (xo->flags & XFRM_DEV_RESUME)) { 147 if (err) { 148 XFRM_INC_STATS(xs_net(x), LINUX_MIB_XFRMOUTSTATEPROTOERROR); 149 kfree_skb(skb); 150 return; 151 } 152 153 skb_push(skb, skb->data - skb_mac_header(skb)); 154 secpath_reset(skb); 155 xfrm_dev_resume(skb); 156 } else { 157 xfrm_output_resume(skb, err); 158 } 159 } 160 161 /* Move ESP header back into place. */ 162 static void esp_restore_header(struct sk_buff *skb, unsigned int offset) 163 { 164 struct ip_esp_hdr *esph = (void *)(skb->data + offset); 165 void *tmp = ESP_SKB_CB(skb)->tmp; 166 __be32 *seqhi = esp_tmp_seqhi(tmp); 167 168 esph->seq_no = esph->spi; 169 esph->spi = *seqhi; 170 } 171 172 static void esp_output_restore_header(struct sk_buff *skb) 173 { 174 esp_restore_header(skb, skb_transport_offset(skb) - sizeof(__be32)); 175 } 176 177 static struct ip_esp_hdr *esp_output_set_esn(struct sk_buff *skb, 178 struct xfrm_state *x, 179 struct ip_esp_hdr *esph, 180 __be32 *seqhi) 181 { 182 /* For ESN we move the header forward by 4 bytes to 183 * accomodate the high bits. We will move it back after 184 * encryption. 185 */ 186 if ((x->props.flags & XFRM_STATE_ESN)) { 187 struct xfrm_offload *xo = xfrm_offload(skb); 188 189 esph = (void *)(skb_transport_header(skb) - sizeof(__be32)); 190 *seqhi = esph->spi; 191 if (xo) 192 esph->seq_no = htonl(xo->seq.hi); 193 else 194 esph->seq_no = htonl(XFRM_SKB_CB(skb)->seq.output.hi); 195 } 196 197 esph->spi = x->id.spi; 198 199 return esph; 200 } 201 202 static void esp_output_done_esn(struct crypto_async_request *base, int err) 203 { 204 struct sk_buff *skb = base->data; 205 206 esp_output_restore_header(skb); 207 esp_output_done(base, err); 208 } 209 210 static void esp_output_fill_trailer(u8 *tail, int tfclen, int plen, __u8 proto) 211 { 212 /* Fill padding... */ 213 if (tfclen) { 214 memset(tail, 0, tfclen); 215 tail += tfclen; 216 } 217 do { 218 int i; 219 for (i = 0; i < plen - 2; i++) 220 tail[i] = i + 1; 221 } while (0); 222 tail[plen - 2] = plen - 2; 223 tail[plen - 1] = proto; 224 } 225 226 int esp6_output_head(struct xfrm_state *x, struct sk_buff *skb, struct esp_info *esp) 227 { 228 u8 *tail; 229 u8 *vaddr; 230 int nfrags; 231 struct page *page; 232 struct sk_buff *trailer; 233 int tailen = esp->tailen; 234 235 if (!skb_cloned(skb)) { 236 if (tailen <= skb_tailroom(skb)) { 237 nfrags = 1; 238 trailer = skb; 239 tail = skb_tail_pointer(trailer); 240 241 goto skip_cow; 242 } else if ((skb_shinfo(skb)->nr_frags < MAX_SKB_FRAGS) 243 && !skb_has_frag_list(skb)) { 244 int allocsize; 245 struct sock *sk = skb->sk; 246 struct page_frag *pfrag = &x->xfrag; 247 248 esp->inplace = false; 249 250 allocsize = ALIGN(tailen, L1_CACHE_BYTES); 251 252 spin_lock_bh(&x->lock); 253 254 if (unlikely(!skb_page_frag_refill(allocsize, pfrag, GFP_ATOMIC))) { 255 spin_unlock_bh(&x->lock); 256 goto cow; 257 } 258 259 page = pfrag->page; 260 get_page(page); 261 262 vaddr = kmap_atomic(page); 263 264 tail = vaddr + pfrag->offset; 265 266 esp_output_fill_trailer(tail, esp->tfclen, esp->plen, esp->proto); 267 268 kunmap_atomic(vaddr); 269 270 nfrags = skb_shinfo(skb)->nr_frags; 271 272 __skb_fill_page_desc(skb, nfrags, page, pfrag->offset, 273 tailen); 274 skb_shinfo(skb)->nr_frags = ++nfrags; 275 276 pfrag->offset = pfrag->offset + allocsize; 277 278 spin_unlock_bh(&x->lock); 279 280 nfrags++; 281 282 skb->len += tailen; 283 skb->data_len += tailen; 284 skb->truesize += tailen; 285 if (sk && sk_fullsock(sk)) 286 refcount_add(tailen, &sk->sk_wmem_alloc); 287 288 goto out; 289 } 290 } 291 292 cow: 293 nfrags = skb_cow_data(skb, tailen, &trailer); 294 if (nfrags < 0) 295 goto out; 296 tail = skb_tail_pointer(trailer); 297 298 skip_cow: 299 esp_output_fill_trailer(tail, esp->tfclen, esp->plen, esp->proto); 300 pskb_put(skb, trailer, tailen); 301 302 out: 303 return nfrags; 304 } 305 EXPORT_SYMBOL_GPL(esp6_output_head); 306 307 int esp6_output_tail(struct xfrm_state *x, struct sk_buff *skb, struct esp_info *esp) 308 { 309 u8 *iv; 310 int alen; 311 void *tmp; 312 int ivlen; 313 int assoclen; 314 int seqhilen; 315 __be32 *seqhi; 316 struct page *page; 317 struct ip_esp_hdr *esph; 318 struct aead_request *req; 319 struct crypto_aead *aead; 320 struct scatterlist *sg, *dsg; 321 int err = -ENOMEM; 322 323 assoclen = sizeof(struct ip_esp_hdr); 324 seqhilen = 0; 325 326 if (x->props.flags & XFRM_STATE_ESN) { 327 seqhilen += sizeof(__be32); 328 assoclen += sizeof(__be32); 329 } 330 331 aead = x->data; 332 alen = crypto_aead_authsize(aead); 333 ivlen = crypto_aead_ivsize(aead); 334 335 tmp = esp_alloc_tmp(aead, esp->nfrags + 2, seqhilen); 336 if (!tmp) 337 goto error; 338 339 seqhi = esp_tmp_seqhi(tmp); 340 iv = esp_tmp_iv(aead, tmp, seqhilen); 341 req = esp_tmp_req(aead, iv); 342 sg = esp_req_sg(aead, req); 343 344 if (esp->inplace) 345 dsg = sg; 346 else 347 dsg = &sg[esp->nfrags]; 348 349 esph = esp_output_set_esn(skb, x, ip_esp_hdr(skb), seqhi); 350 351 sg_init_table(sg, esp->nfrags); 352 err = skb_to_sgvec(skb, sg, 353 (unsigned char *)esph - skb->data, 354 assoclen + ivlen + esp->clen + alen); 355 if (unlikely(err < 0)) 356 goto error_free; 357 358 if (!esp->inplace) { 359 int allocsize; 360 struct page_frag *pfrag = &x->xfrag; 361 362 allocsize = ALIGN(skb->data_len, L1_CACHE_BYTES); 363 364 spin_lock_bh(&x->lock); 365 if (unlikely(!skb_page_frag_refill(allocsize, pfrag, GFP_ATOMIC))) { 366 spin_unlock_bh(&x->lock); 367 goto error_free; 368 } 369 370 skb_shinfo(skb)->nr_frags = 1; 371 372 page = pfrag->page; 373 get_page(page); 374 /* replace page frags in skb with new page */ 375 __skb_fill_page_desc(skb, 0, page, pfrag->offset, skb->data_len); 376 pfrag->offset = pfrag->offset + allocsize; 377 spin_unlock_bh(&x->lock); 378 379 sg_init_table(dsg, skb_shinfo(skb)->nr_frags + 1); 380 err = skb_to_sgvec(skb, dsg, 381 (unsigned char *)esph - skb->data, 382 assoclen + ivlen + esp->clen + alen); 383 if (unlikely(err < 0)) 384 goto error_free; 385 } 386 387 if ((x->props.flags & XFRM_STATE_ESN)) 388 aead_request_set_callback(req, 0, esp_output_done_esn, skb); 389 else 390 aead_request_set_callback(req, 0, esp_output_done, skb); 391 392 aead_request_set_crypt(req, sg, dsg, ivlen + esp->clen, iv); 393 aead_request_set_ad(req, assoclen); 394 395 memset(iv, 0, ivlen); 396 memcpy(iv + ivlen - min(ivlen, 8), (u8 *)&esp->seqno + 8 - min(ivlen, 8), 397 min(ivlen, 8)); 398 399 ESP_SKB_CB(skb)->tmp = tmp; 400 err = crypto_aead_encrypt(req); 401 402 switch (err) { 403 case -EINPROGRESS: 404 goto error; 405 406 case -ENOSPC: 407 err = NET_XMIT_DROP; 408 break; 409 410 case 0: 411 if ((x->props.flags & XFRM_STATE_ESN)) 412 esp_output_restore_header(skb); 413 } 414 415 if (sg != dsg) 416 esp_ssg_unref(x, tmp); 417 418 error_free: 419 kfree(tmp); 420 error: 421 return err; 422 } 423 EXPORT_SYMBOL_GPL(esp6_output_tail); 424 425 static int esp6_output(struct xfrm_state *x, struct sk_buff *skb) 426 { 427 int alen; 428 int blksize; 429 struct ip_esp_hdr *esph; 430 struct crypto_aead *aead; 431 struct esp_info esp; 432 433 esp.inplace = true; 434 435 esp.proto = *skb_mac_header(skb); 436 *skb_mac_header(skb) = IPPROTO_ESP; 437 438 /* skb is pure payload to encrypt */ 439 440 aead = x->data; 441 alen = crypto_aead_authsize(aead); 442 443 esp.tfclen = 0; 444 if (x->tfcpad) { 445 struct xfrm_dst *dst = (struct xfrm_dst *)skb_dst(skb); 446 u32 padto; 447 448 padto = min(x->tfcpad, xfrm_state_mtu(x, dst->child_mtu_cached)); 449 if (skb->len < padto) 450 esp.tfclen = padto - skb->len; 451 } 452 blksize = ALIGN(crypto_aead_blocksize(aead), 4); 453 esp.clen = ALIGN(skb->len + 2 + esp.tfclen, blksize); 454 esp.plen = esp.clen - skb->len - esp.tfclen; 455 esp.tailen = esp.tfclen + esp.plen + alen; 456 457 esp.nfrags = esp6_output_head(x, skb, &esp); 458 if (esp.nfrags < 0) 459 return esp.nfrags; 460 461 esph = ip_esp_hdr(skb); 462 esph->spi = x->id.spi; 463 464 esph->seq_no = htonl(XFRM_SKB_CB(skb)->seq.output.low); 465 esp.seqno = cpu_to_be64(XFRM_SKB_CB(skb)->seq.output.low + 466 ((u64)XFRM_SKB_CB(skb)->seq.output.hi << 32)); 467 468 skb_push(skb, -skb_network_offset(skb)); 469 470 return esp6_output_tail(x, skb, &esp); 471 } 472 473 static inline int esp_remove_trailer(struct sk_buff *skb) 474 { 475 struct xfrm_state *x = xfrm_input_state(skb); 476 struct xfrm_offload *xo = xfrm_offload(skb); 477 struct crypto_aead *aead = x->data; 478 int alen, hlen, elen; 479 int padlen, trimlen; 480 __wsum csumdiff; 481 u8 nexthdr[2]; 482 int ret; 483 484 alen = crypto_aead_authsize(aead); 485 hlen = sizeof(struct ip_esp_hdr) + crypto_aead_ivsize(aead); 486 elen = skb->len - hlen; 487 488 if (xo && (xo->flags & XFRM_ESP_NO_TRAILER)) { 489 ret = xo->proto; 490 goto out; 491 } 492 493 ret = skb_copy_bits(skb, skb->len - alen - 2, nexthdr, 2); 494 BUG_ON(ret); 495 496 ret = -EINVAL; 497 padlen = nexthdr[0]; 498 if (padlen + 2 + alen >= elen) { 499 net_dbg_ratelimited("ipsec esp packet is garbage padlen=%d, elen=%d\n", 500 padlen + 2, elen - alen); 501 goto out; 502 } 503 504 trimlen = alen + padlen + 2; 505 if (skb->ip_summed == CHECKSUM_COMPLETE) { 506 csumdiff = skb_checksum(skb, skb->len - trimlen, trimlen, 0); 507 skb->csum = csum_block_sub(skb->csum, csumdiff, 508 skb->len - trimlen); 509 } 510 pskb_trim(skb, skb->len - trimlen); 511 512 ret = nexthdr[1]; 513 514 out: 515 return ret; 516 } 517 518 int esp6_input_done2(struct sk_buff *skb, int err) 519 { 520 struct xfrm_state *x = xfrm_input_state(skb); 521 struct xfrm_offload *xo = xfrm_offload(skb); 522 struct crypto_aead *aead = x->data; 523 int hlen = sizeof(struct ip_esp_hdr) + crypto_aead_ivsize(aead); 524 int hdr_len = skb_network_header_len(skb); 525 526 if (!xo || (xo && !(xo->flags & CRYPTO_DONE))) 527 kfree(ESP_SKB_CB(skb)->tmp); 528 529 if (unlikely(err)) 530 goto out; 531 532 err = esp_remove_trailer(skb); 533 if (unlikely(err < 0)) 534 goto out; 535 536 skb_postpull_rcsum(skb, skb_network_header(skb), 537 skb_network_header_len(skb)); 538 skb_pull_rcsum(skb, hlen); 539 if (x->props.mode == XFRM_MODE_TUNNEL) 540 skb_reset_transport_header(skb); 541 else 542 skb_set_transport_header(skb, -hdr_len); 543 544 /* RFC4303: Drop dummy packets without any error */ 545 if (err == IPPROTO_NONE) 546 err = -EINVAL; 547 548 out: 549 return err; 550 } 551 EXPORT_SYMBOL_GPL(esp6_input_done2); 552 553 static void esp_input_done(struct crypto_async_request *base, int err) 554 { 555 struct sk_buff *skb = base->data; 556 557 xfrm_input_resume(skb, esp6_input_done2(skb, err)); 558 } 559 560 static void esp_input_restore_header(struct sk_buff *skb) 561 { 562 esp_restore_header(skb, 0); 563 __skb_pull(skb, 4); 564 } 565 566 static void esp_input_set_header(struct sk_buff *skb, __be32 *seqhi) 567 { 568 struct xfrm_state *x = xfrm_input_state(skb); 569 570 /* For ESN we move the header forward by 4 bytes to 571 * accomodate the high bits. We will move it back after 572 * decryption. 573 */ 574 if ((x->props.flags & XFRM_STATE_ESN)) { 575 struct ip_esp_hdr *esph = skb_push(skb, 4); 576 577 *seqhi = esph->spi; 578 esph->spi = esph->seq_no; 579 esph->seq_no = XFRM_SKB_CB(skb)->seq.input.hi; 580 } 581 } 582 583 static void esp_input_done_esn(struct crypto_async_request *base, int err) 584 { 585 struct sk_buff *skb = base->data; 586 587 esp_input_restore_header(skb); 588 esp_input_done(base, err); 589 } 590 591 static int esp6_input(struct xfrm_state *x, struct sk_buff *skb) 592 { 593 struct crypto_aead *aead = x->data; 594 struct aead_request *req; 595 struct sk_buff *trailer; 596 int ivlen = crypto_aead_ivsize(aead); 597 int elen = skb->len - sizeof(struct ip_esp_hdr) - ivlen; 598 int nfrags; 599 int assoclen; 600 int seqhilen; 601 int ret = 0; 602 void *tmp; 603 __be32 *seqhi; 604 u8 *iv; 605 struct scatterlist *sg; 606 607 if (!pskb_may_pull(skb, sizeof(struct ip_esp_hdr) + ivlen)) { 608 ret = -EINVAL; 609 goto out; 610 } 611 612 if (elen <= 0) { 613 ret = -EINVAL; 614 goto out; 615 } 616 617 assoclen = sizeof(struct ip_esp_hdr); 618 seqhilen = 0; 619 620 if (x->props.flags & XFRM_STATE_ESN) { 621 seqhilen += sizeof(__be32); 622 assoclen += seqhilen; 623 } 624 625 if (!skb_cloned(skb)) { 626 if (!skb_is_nonlinear(skb)) { 627 nfrags = 1; 628 629 goto skip_cow; 630 } else if (!skb_has_frag_list(skb)) { 631 nfrags = skb_shinfo(skb)->nr_frags; 632 nfrags++; 633 634 goto skip_cow; 635 } 636 } 637 638 nfrags = skb_cow_data(skb, 0, &trailer); 639 if (nfrags < 0) { 640 ret = -EINVAL; 641 goto out; 642 } 643 644 skip_cow: 645 ret = -ENOMEM; 646 tmp = esp_alloc_tmp(aead, nfrags, seqhilen); 647 if (!tmp) 648 goto out; 649 650 ESP_SKB_CB(skb)->tmp = tmp; 651 seqhi = esp_tmp_seqhi(tmp); 652 iv = esp_tmp_iv(aead, tmp, seqhilen); 653 req = esp_tmp_req(aead, iv); 654 sg = esp_req_sg(aead, req); 655 656 esp_input_set_header(skb, seqhi); 657 658 sg_init_table(sg, nfrags); 659 ret = skb_to_sgvec(skb, sg, 0, skb->len); 660 if (unlikely(ret < 0)) { 661 kfree(tmp); 662 goto out; 663 } 664 665 skb->ip_summed = CHECKSUM_NONE; 666 667 if ((x->props.flags & XFRM_STATE_ESN)) 668 aead_request_set_callback(req, 0, esp_input_done_esn, skb); 669 else 670 aead_request_set_callback(req, 0, esp_input_done, skb); 671 672 aead_request_set_crypt(req, sg, sg, elen + ivlen, iv); 673 aead_request_set_ad(req, assoclen); 674 675 ret = crypto_aead_decrypt(req); 676 if (ret == -EINPROGRESS) 677 goto out; 678 679 if ((x->props.flags & XFRM_STATE_ESN)) 680 esp_input_restore_header(skb); 681 682 ret = esp6_input_done2(skb, ret); 683 684 out: 685 return ret; 686 } 687 688 static int esp6_err(struct sk_buff *skb, struct inet6_skb_parm *opt, 689 u8 type, u8 code, int offset, __be32 info) 690 { 691 struct net *net = dev_net(skb->dev); 692 const struct ipv6hdr *iph = (const struct ipv6hdr *)skb->data; 693 struct ip_esp_hdr *esph = (struct ip_esp_hdr *)(skb->data + offset); 694 struct xfrm_state *x; 695 696 if (type != ICMPV6_PKT_TOOBIG && 697 type != NDISC_REDIRECT) 698 return 0; 699 700 x = xfrm_state_lookup(net, skb->mark, (const xfrm_address_t *)&iph->daddr, 701 esph->spi, IPPROTO_ESP, AF_INET6); 702 if (!x) 703 return 0; 704 705 if (type == NDISC_REDIRECT) 706 ip6_redirect(skb, net, skb->dev->ifindex, 0, 707 sock_net_uid(net, NULL)); 708 else 709 ip6_update_pmtu(skb, net, info, 0, 0, sock_net_uid(net, NULL)); 710 xfrm_state_put(x); 711 712 return 0; 713 } 714 715 static void esp6_destroy(struct xfrm_state *x) 716 { 717 struct crypto_aead *aead = x->data; 718 719 if (!aead) 720 return; 721 722 crypto_free_aead(aead); 723 } 724 725 static int esp_init_aead(struct xfrm_state *x) 726 { 727 char aead_name[CRYPTO_MAX_ALG_NAME]; 728 struct crypto_aead *aead; 729 int err; 730 731 err = -ENAMETOOLONG; 732 if (snprintf(aead_name, CRYPTO_MAX_ALG_NAME, "%s(%s)", 733 x->geniv, x->aead->alg_name) >= CRYPTO_MAX_ALG_NAME) 734 goto error; 735 736 aead = crypto_alloc_aead(aead_name, 0, 0); 737 err = PTR_ERR(aead); 738 if (IS_ERR(aead)) 739 goto error; 740 741 x->data = aead; 742 743 err = crypto_aead_setkey(aead, x->aead->alg_key, 744 (x->aead->alg_key_len + 7) / 8); 745 if (err) 746 goto error; 747 748 err = crypto_aead_setauthsize(aead, x->aead->alg_icv_len / 8); 749 if (err) 750 goto error; 751 752 error: 753 return err; 754 } 755 756 static int esp_init_authenc(struct xfrm_state *x) 757 { 758 struct crypto_aead *aead; 759 struct crypto_authenc_key_param *param; 760 struct rtattr *rta; 761 char *key; 762 char *p; 763 char authenc_name[CRYPTO_MAX_ALG_NAME]; 764 unsigned int keylen; 765 int err; 766 767 err = -EINVAL; 768 if (!x->ealg) 769 goto error; 770 771 err = -ENAMETOOLONG; 772 773 if ((x->props.flags & XFRM_STATE_ESN)) { 774 if (snprintf(authenc_name, CRYPTO_MAX_ALG_NAME, 775 "%s%sauthencesn(%s,%s)%s", 776 x->geniv ?: "", x->geniv ? "(" : "", 777 x->aalg ? x->aalg->alg_name : "digest_null", 778 x->ealg->alg_name, 779 x->geniv ? ")" : "") >= CRYPTO_MAX_ALG_NAME) 780 goto error; 781 } else { 782 if (snprintf(authenc_name, CRYPTO_MAX_ALG_NAME, 783 "%s%sauthenc(%s,%s)%s", 784 x->geniv ?: "", x->geniv ? "(" : "", 785 x->aalg ? x->aalg->alg_name : "digest_null", 786 x->ealg->alg_name, 787 x->geniv ? ")" : "") >= CRYPTO_MAX_ALG_NAME) 788 goto error; 789 } 790 791 aead = crypto_alloc_aead(authenc_name, 0, 0); 792 err = PTR_ERR(aead); 793 if (IS_ERR(aead)) 794 goto error; 795 796 x->data = aead; 797 798 keylen = (x->aalg ? (x->aalg->alg_key_len + 7) / 8 : 0) + 799 (x->ealg->alg_key_len + 7) / 8 + RTA_SPACE(sizeof(*param)); 800 err = -ENOMEM; 801 key = kmalloc(keylen, GFP_KERNEL); 802 if (!key) 803 goto error; 804 805 p = key; 806 rta = (void *)p; 807 rta->rta_type = CRYPTO_AUTHENC_KEYA_PARAM; 808 rta->rta_len = RTA_LENGTH(sizeof(*param)); 809 param = RTA_DATA(rta); 810 p += RTA_SPACE(sizeof(*param)); 811 812 if (x->aalg) { 813 struct xfrm_algo_desc *aalg_desc; 814 815 memcpy(p, x->aalg->alg_key, (x->aalg->alg_key_len + 7) / 8); 816 p += (x->aalg->alg_key_len + 7) / 8; 817 818 aalg_desc = xfrm_aalg_get_byname(x->aalg->alg_name, 0); 819 BUG_ON(!aalg_desc); 820 821 err = -EINVAL; 822 if (aalg_desc->uinfo.auth.icv_fullbits / 8 != 823 crypto_aead_authsize(aead)) { 824 pr_info("ESP: %s digestsize %u != %hu\n", 825 x->aalg->alg_name, 826 crypto_aead_authsize(aead), 827 aalg_desc->uinfo.auth.icv_fullbits / 8); 828 goto free_key; 829 } 830 831 err = crypto_aead_setauthsize( 832 aead, x->aalg->alg_trunc_len / 8); 833 if (err) 834 goto free_key; 835 } 836 837 param->enckeylen = cpu_to_be32((x->ealg->alg_key_len + 7) / 8); 838 memcpy(p, x->ealg->alg_key, (x->ealg->alg_key_len + 7) / 8); 839 840 err = crypto_aead_setkey(aead, key, keylen); 841 842 free_key: 843 kfree(key); 844 845 error: 846 return err; 847 } 848 849 static int esp6_init_state(struct xfrm_state *x) 850 { 851 struct crypto_aead *aead; 852 u32 align; 853 int err; 854 855 if (x->encap) 856 return -EINVAL; 857 858 x->data = NULL; 859 860 if (x->aead) 861 err = esp_init_aead(x); 862 else 863 err = esp_init_authenc(x); 864 865 if (err) 866 goto error; 867 868 aead = x->data; 869 870 x->props.header_len = sizeof(struct ip_esp_hdr) + 871 crypto_aead_ivsize(aead); 872 switch (x->props.mode) { 873 case XFRM_MODE_BEET: 874 if (x->sel.family != AF_INET6) 875 x->props.header_len += IPV4_BEET_PHMAXLEN + 876 (sizeof(struct ipv6hdr) - sizeof(struct iphdr)); 877 break; 878 default: 879 case XFRM_MODE_TRANSPORT: 880 break; 881 case XFRM_MODE_TUNNEL: 882 x->props.header_len += sizeof(struct ipv6hdr); 883 break; 884 } 885 886 align = ALIGN(crypto_aead_blocksize(aead), 4); 887 x->props.trailer_len = align + 1 + crypto_aead_authsize(aead); 888 889 error: 890 return err; 891 } 892 893 static int esp6_rcv_cb(struct sk_buff *skb, int err) 894 { 895 return 0; 896 } 897 898 static const struct xfrm_type esp6_type = { 899 .description = "ESP6", 900 .owner = THIS_MODULE, 901 .proto = IPPROTO_ESP, 902 .flags = XFRM_TYPE_REPLAY_PROT, 903 .init_state = esp6_init_state, 904 .destructor = esp6_destroy, 905 .input = esp6_input, 906 .output = esp6_output, 907 .hdr_offset = xfrm6_find_1stfragopt, 908 }; 909 910 static struct xfrm6_protocol esp6_protocol = { 911 .handler = xfrm6_rcv, 912 .cb_handler = esp6_rcv_cb, 913 .err_handler = esp6_err, 914 .priority = 0, 915 }; 916 917 static int __init esp6_init(void) 918 { 919 if (xfrm_register_type(&esp6_type, AF_INET6) < 0) { 920 pr_info("%s: can't add xfrm type\n", __func__); 921 return -EAGAIN; 922 } 923 if (xfrm6_protocol_register(&esp6_protocol, IPPROTO_ESP) < 0) { 924 pr_info("%s: can't add protocol\n", __func__); 925 xfrm_unregister_type(&esp6_type, AF_INET6); 926 return -EAGAIN; 927 } 928 929 return 0; 930 } 931 932 static void __exit esp6_fini(void) 933 { 934 if (xfrm6_protocol_deregister(&esp6_protocol, IPPROTO_ESP) < 0) 935 pr_info("%s: can't remove protocol\n", __func__); 936 xfrm_unregister_type(&esp6_type, AF_INET6); 937 } 938 939 module_init(esp6_init); 940 module_exit(esp6_fini); 941 942 MODULE_LICENSE("GPL"); 943 MODULE_ALIAS_XFRM_TYPE(AF_INET6, XFRM_PROTO_ESP); 944