1 /* 2 * xfrm algorithm interface 3 * 4 * Copyright (c) 2002 James Morris <jmorris@intercode.com.au> 5 * 6 * This program is free software; you can redistribute it and/or modify it 7 * under the terms of the GNU General Public License as published by the Free 8 * Software Foundation; either version 2 of the License, or (at your option) 9 * any later version. 10 */ 11 12 #include <linux/config.h> 13 #include <linux/module.h> 14 #include <linux/kernel.h> 15 #include <linux/pfkeyv2.h> 16 #include <linux/crypto.h> 17 #include <net/xfrm.h> 18 #if defined(CONFIG_INET_AH) || defined(CONFIG_INET_AH_MODULE) || defined(CONFIG_INET6_AH) || defined(CONFIG_INET6_AH_MODULE) 19 #include <net/ah.h> 20 #endif 21 #if defined(CONFIG_INET_ESP) || defined(CONFIG_INET_ESP_MODULE) || defined(CONFIG_INET6_ESP) || defined(CONFIG_INET6_ESP_MODULE) 22 #include <net/esp.h> 23 #endif 24 #include <asm/scatterlist.h> 25 26 /* 27 * Algorithms supported by IPsec. These entries contain properties which 28 * are used in key negotiation and xfrm processing, and are used to verify 29 * that instantiated crypto transforms have correct parameters for IPsec 30 * purposes. 31 */ 32 static struct xfrm_algo_desc aalg_list[] = { 33 { 34 .name = "digest_null", 35 36 .uinfo = { 37 .auth = { 38 .icv_truncbits = 0, 39 .icv_fullbits = 0, 40 } 41 }, 42 43 .desc = { 44 .sadb_alg_id = SADB_X_AALG_NULL, 45 .sadb_alg_ivlen = 0, 46 .sadb_alg_minbits = 0, 47 .sadb_alg_maxbits = 0 48 } 49 }, 50 { 51 .name = "md5", 52 53 .uinfo = { 54 .auth = { 55 .icv_truncbits = 96, 56 .icv_fullbits = 128, 57 } 58 }, 59 60 .desc = { 61 .sadb_alg_id = SADB_AALG_MD5HMAC, 62 .sadb_alg_ivlen = 0, 63 .sadb_alg_minbits = 128, 64 .sadb_alg_maxbits = 128 65 } 66 }, 67 { 68 .name = "sha1", 69 70 .uinfo = { 71 .auth = { 72 .icv_truncbits = 96, 73 .icv_fullbits = 160, 74 } 75 }, 76 77 .desc = { 78 .sadb_alg_id = SADB_AALG_SHA1HMAC, 79 .sadb_alg_ivlen = 0, 80 .sadb_alg_minbits = 160, 81 .sadb_alg_maxbits = 160 82 } 83 }, 84 { 85 .name = "sha256", 86 87 .uinfo = { 88 .auth = { 89 .icv_truncbits = 96, 90 .icv_fullbits = 256, 91 } 92 }, 93 94 .desc = { 95 .sadb_alg_id = SADB_X_AALG_SHA2_256HMAC, 96 .sadb_alg_ivlen = 0, 97 .sadb_alg_minbits = 256, 98 .sadb_alg_maxbits = 256 99 } 100 }, 101 { 102 .name = "ripemd160", 103 104 .uinfo = { 105 .auth = { 106 .icv_truncbits = 96, 107 .icv_fullbits = 160, 108 } 109 }, 110 111 .desc = { 112 .sadb_alg_id = SADB_X_AALG_RIPEMD160HMAC, 113 .sadb_alg_ivlen = 0, 114 .sadb_alg_minbits = 160, 115 .sadb_alg_maxbits = 160 116 } 117 }, 118 }; 119 120 static struct xfrm_algo_desc ealg_list[] = { 121 { 122 .name = "cipher_null", 123 124 .uinfo = { 125 .encr = { 126 .blockbits = 8, 127 .defkeybits = 0, 128 } 129 }, 130 131 .desc = { 132 .sadb_alg_id = SADB_EALG_NULL, 133 .sadb_alg_ivlen = 0, 134 .sadb_alg_minbits = 0, 135 .sadb_alg_maxbits = 0 136 } 137 }, 138 { 139 .name = "des", 140 141 .uinfo = { 142 .encr = { 143 .blockbits = 64, 144 .defkeybits = 64, 145 } 146 }, 147 148 .desc = { 149 .sadb_alg_id = SADB_EALG_DESCBC, 150 .sadb_alg_ivlen = 8, 151 .sadb_alg_minbits = 64, 152 .sadb_alg_maxbits = 64 153 } 154 }, 155 { 156 .name = "des3_ede", 157 158 .uinfo = { 159 .encr = { 160 .blockbits = 64, 161 .defkeybits = 192, 162 } 163 }, 164 165 .desc = { 166 .sadb_alg_id = SADB_EALG_3DESCBC, 167 .sadb_alg_ivlen = 8, 168 .sadb_alg_minbits = 192, 169 .sadb_alg_maxbits = 192 170 } 171 }, 172 { 173 .name = "cast128", 174 175 .uinfo = { 176 .encr = { 177 .blockbits = 64, 178 .defkeybits = 128, 179 } 180 }, 181 182 .desc = { 183 .sadb_alg_id = SADB_X_EALG_CASTCBC, 184 .sadb_alg_ivlen = 8, 185 .sadb_alg_minbits = 40, 186 .sadb_alg_maxbits = 128 187 } 188 }, 189 { 190 .name = "blowfish", 191 192 .uinfo = { 193 .encr = { 194 .blockbits = 64, 195 .defkeybits = 128, 196 } 197 }, 198 199 .desc = { 200 .sadb_alg_id = SADB_X_EALG_BLOWFISHCBC, 201 .sadb_alg_ivlen = 8, 202 .sadb_alg_minbits = 40, 203 .sadb_alg_maxbits = 448 204 } 205 }, 206 { 207 .name = "aes", 208 209 .uinfo = { 210 .encr = { 211 .blockbits = 128, 212 .defkeybits = 128, 213 } 214 }, 215 216 .desc = { 217 .sadb_alg_id = SADB_X_EALG_AESCBC, 218 .sadb_alg_ivlen = 8, 219 .sadb_alg_minbits = 128, 220 .sadb_alg_maxbits = 256 221 } 222 }, 223 { 224 .name = "serpent", 225 226 .uinfo = { 227 .encr = { 228 .blockbits = 128, 229 .defkeybits = 128, 230 } 231 }, 232 233 .desc = { 234 .sadb_alg_id = SADB_X_EALG_SERPENTCBC, 235 .sadb_alg_ivlen = 8, 236 .sadb_alg_minbits = 128, 237 .sadb_alg_maxbits = 256, 238 } 239 }, 240 { 241 .name = "twofish", 242 243 .uinfo = { 244 .encr = { 245 .blockbits = 128, 246 .defkeybits = 128, 247 } 248 }, 249 250 .desc = { 251 .sadb_alg_id = SADB_X_EALG_TWOFISHCBC, 252 .sadb_alg_ivlen = 8, 253 .sadb_alg_minbits = 128, 254 .sadb_alg_maxbits = 256 255 } 256 }, 257 }; 258 259 static struct xfrm_algo_desc calg_list[] = { 260 { 261 .name = "deflate", 262 .uinfo = { 263 .comp = { 264 .threshold = 90, 265 } 266 }, 267 .desc = { .sadb_alg_id = SADB_X_CALG_DEFLATE } 268 }, 269 { 270 .name = "lzs", 271 .uinfo = { 272 .comp = { 273 .threshold = 90, 274 } 275 }, 276 .desc = { .sadb_alg_id = SADB_X_CALG_LZS } 277 }, 278 { 279 .name = "lzjh", 280 .uinfo = { 281 .comp = { 282 .threshold = 50, 283 } 284 }, 285 .desc = { .sadb_alg_id = SADB_X_CALG_LZJH } 286 }, 287 }; 288 289 static inline int aalg_entries(void) 290 { 291 return ARRAY_SIZE(aalg_list); 292 } 293 294 static inline int ealg_entries(void) 295 { 296 return ARRAY_SIZE(ealg_list); 297 } 298 299 static inline int calg_entries(void) 300 { 301 return ARRAY_SIZE(calg_list); 302 } 303 304 /* Todo: generic iterators */ 305 struct xfrm_algo_desc *xfrm_aalg_get_byid(int alg_id) 306 { 307 int i; 308 309 for (i = 0; i < aalg_entries(); i++) { 310 if (aalg_list[i].desc.sadb_alg_id == alg_id) { 311 if (aalg_list[i].available) 312 return &aalg_list[i]; 313 else 314 break; 315 } 316 } 317 return NULL; 318 } 319 EXPORT_SYMBOL_GPL(xfrm_aalg_get_byid); 320 321 struct xfrm_algo_desc *xfrm_ealg_get_byid(int alg_id) 322 { 323 int i; 324 325 for (i = 0; i < ealg_entries(); i++) { 326 if (ealg_list[i].desc.sadb_alg_id == alg_id) { 327 if (ealg_list[i].available) 328 return &ealg_list[i]; 329 else 330 break; 331 } 332 } 333 return NULL; 334 } 335 EXPORT_SYMBOL_GPL(xfrm_ealg_get_byid); 336 337 struct xfrm_algo_desc *xfrm_calg_get_byid(int alg_id) 338 { 339 int i; 340 341 for (i = 0; i < calg_entries(); i++) { 342 if (calg_list[i].desc.sadb_alg_id == alg_id) { 343 if (calg_list[i].available) 344 return &calg_list[i]; 345 else 346 break; 347 } 348 } 349 return NULL; 350 } 351 EXPORT_SYMBOL_GPL(xfrm_calg_get_byid); 352 353 static struct xfrm_algo_desc *xfrm_get_byname(struct xfrm_algo_desc *list, 354 int entries, char *name, 355 int probe) 356 { 357 int i, status; 358 359 if (!name) 360 return NULL; 361 362 for (i = 0; i < entries; i++) { 363 if (strcmp(name, list[i].name)) 364 continue; 365 366 if (list[i].available) 367 return &list[i]; 368 369 if (!probe) 370 break; 371 372 status = crypto_alg_available(name, 0); 373 if (!status) 374 break; 375 376 list[i].available = status; 377 return &list[i]; 378 } 379 return NULL; 380 } 381 382 struct xfrm_algo_desc *xfrm_aalg_get_byname(char *name, int probe) 383 { 384 return xfrm_get_byname(aalg_list, aalg_entries(), name, probe); 385 } 386 EXPORT_SYMBOL_GPL(xfrm_aalg_get_byname); 387 388 struct xfrm_algo_desc *xfrm_ealg_get_byname(char *name, int probe) 389 { 390 return xfrm_get_byname(ealg_list, ealg_entries(), name, probe); 391 } 392 EXPORT_SYMBOL_GPL(xfrm_ealg_get_byname); 393 394 struct xfrm_algo_desc *xfrm_calg_get_byname(char *name, int probe) 395 { 396 return xfrm_get_byname(calg_list, calg_entries(), name, probe); 397 } 398 EXPORT_SYMBOL_GPL(xfrm_calg_get_byname); 399 400 struct xfrm_algo_desc *xfrm_aalg_get_byidx(unsigned int idx) 401 { 402 if (idx >= aalg_entries()) 403 return NULL; 404 405 return &aalg_list[idx]; 406 } 407 EXPORT_SYMBOL_GPL(xfrm_aalg_get_byidx); 408 409 struct xfrm_algo_desc *xfrm_ealg_get_byidx(unsigned int idx) 410 { 411 if (idx >= ealg_entries()) 412 return NULL; 413 414 return &ealg_list[idx]; 415 } 416 EXPORT_SYMBOL_GPL(xfrm_ealg_get_byidx); 417 418 /* 419 * Probe for the availability of crypto algorithms, and set the available 420 * flag for any algorithms found on the system. This is typically called by 421 * pfkey during userspace SA add, update or register. 422 */ 423 void xfrm_probe_algs(void) 424 { 425 #ifdef CONFIG_CRYPTO 426 int i, status; 427 428 BUG_ON(in_softirq()); 429 430 for (i = 0; i < aalg_entries(); i++) { 431 status = crypto_alg_available(aalg_list[i].name, 0); 432 if (aalg_list[i].available != status) 433 aalg_list[i].available = status; 434 } 435 436 for (i = 0; i < ealg_entries(); i++) { 437 status = crypto_alg_available(ealg_list[i].name, 0); 438 if (ealg_list[i].available != status) 439 ealg_list[i].available = status; 440 } 441 442 for (i = 0; i < calg_entries(); i++) { 443 status = crypto_alg_available(calg_list[i].name, 0); 444 if (calg_list[i].available != status) 445 calg_list[i].available = status; 446 } 447 #endif 448 } 449 EXPORT_SYMBOL_GPL(xfrm_probe_algs); 450 451 int xfrm_count_auth_supported(void) 452 { 453 int i, n; 454 455 for (i = 0, n = 0; i < aalg_entries(); i++) 456 if (aalg_list[i].available) 457 n++; 458 return n; 459 } 460 EXPORT_SYMBOL_GPL(xfrm_count_auth_supported); 461 462 int xfrm_count_enc_supported(void) 463 { 464 int i, n; 465 466 for (i = 0, n = 0; i < ealg_entries(); i++) 467 if (ealg_list[i].available) 468 n++; 469 return n; 470 } 471 EXPORT_SYMBOL_GPL(xfrm_count_enc_supported); 472 473 /* Move to common area: it is shared with AH. */ 474 475 void skb_icv_walk(const struct sk_buff *skb, struct crypto_tfm *tfm, 476 int offset, int len, icv_update_fn_t icv_update) 477 { 478 int start = skb_headlen(skb); 479 int i, copy = start - offset; 480 struct scatterlist sg; 481 482 /* Checksum header. */ 483 if (copy > 0) { 484 if (copy > len) 485 copy = len; 486 487 sg.page = virt_to_page(skb->data + offset); 488 sg.offset = (unsigned long)(skb->data + offset) % PAGE_SIZE; 489 sg.length = copy; 490 491 icv_update(tfm, &sg, 1); 492 493 if ((len -= copy) == 0) 494 return; 495 offset += copy; 496 } 497 498 for (i = 0; i < skb_shinfo(skb)->nr_frags; i++) { 499 int end; 500 501 BUG_TRAP(start <= offset + len); 502 503 end = start + skb_shinfo(skb)->frags[i].size; 504 if ((copy = end - offset) > 0) { 505 skb_frag_t *frag = &skb_shinfo(skb)->frags[i]; 506 507 if (copy > len) 508 copy = len; 509 510 sg.page = frag->page; 511 sg.offset = frag->page_offset + offset-start; 512 sg.length = copy; 513 514 icv_update(tfm, &sg, 1); 515 516 if (!(len -= copy)) 517 return; 518 offset += copy; 519 } 520 start = end; 521 } 522 523 if (skb_shinfo(skb)->frag_list) { 524 struct sk_buff *list = skb_shinfo(skb)->frag_list; 525 526 for (; list; list = list->next) { 527 int end; 528 529 BUG_TRAP(start <= offset + len); 530 531 end = start + list->len; 532 if ((copy = end - offset) > 0) { 533 if (copy > len) 534 copy = len; 535 skb_icv_walk(list, tfm, offset-start, copy, icv_update); 536 if ((len -= copy) == 0) 537 return; 538 offset += copy; 539 } 540 start = end; 541 } 542 } 543 if (len) 544 BUG(); 545 } 546 EXPORT_SYMBOL_GPL(skb_icv_walk); 547 548 #if defined(CONFIG_INET_ESP) || defined(CONFIG_INET_ESP_MODULE) || defined(CONFIG_INET6_ESP) || defined(CONFIG_INET6_ESP_MODULE) 549 550 /* Looking generic it is not used in another places. */ 551 552 int 553 skb_to_sgvec(struct sk_buff *skb, struct scatterlist *sg, int offset, int len) 554 { 555 int start = skb_headlen(skb); 556 int i, copy = start - offset; 557 int elt = 0; 558 559 if (copy > 0) { 560 if (copy > len) 561 copy = len; 562 sg[elt].page = virt_to_page(skb->data + offset); 563 sg[elt].offset = (unsigned long)(skb->data + offset) % PAGE_SIZE; 564 sg[elt].length = copy; 565 elt++; 566 if ((len -= copy) == 0) 567 return elt; 568 offset += copy; 569 } 570 571 for (i = 0; i < skb_shinfo(skb)->nr_frags; i++) { 572 int end; 573 574 BUG_TRAP(start <= offset + len); 575 576 end = start + skb_shinfo(skb)->frags[i].size; 577 if ((copy = end - offset) > 0) { 578 skb_frag_t *frag = &skb_shinfo(skb)->frags[i]; 579 580 if (copy > len) 581 copy = len; 582 sg[elt].page = frag->page; 583 sg[elt].offset = frag->page_offset+offset-start; 584 sg[elt].length = copy; 585 elt++; 586 if (!(len -= copy)) 587 return elt; 588 offset += copy; 589 } 590 start = end; 591 } 592 593 if (skb_shinfo(skb)->frag_list) { 594 struct sk_buff *list = skb_shinfo(skb)->frag_list; 595 596 for (; list; list = list->next) { 597 int end; 598 599 BUG_TRAP(start <= offset + len); 600 601 end = start + list->len; 602 if ((copy = end - offset) > 0) { 603 if (copy > len) 604 copy = len; 605 elt += skb_to_sgvec(list, sg+elt, offset - start, copy); 606 if ((len -= copy) == 0) 607 return elt; 608 offset += copy; 609 } 610 start = end; 611 } 612 } 613 if (len) 614 BUG(); 615 return elt; 616 } 617 EXPORT_SYMBOL_GPL(skb_to_sgvec); 618 619 /* Check that skb data bits are writable. If they are not, copy data 620 * to newly created private area. If "tailbits" is given, make sure that 621 * tailbits bytes beyond current end of skb are writable. 622 * 623 * Returns amount of elements of scatterlist to load for subsequent 624 * transformations and pointer to writable trailer skb. 625 */ 626 627 int skb_cow_data(struct sk_buff *skb, int tailbits, struct sk_buff **trailer) 628 { 629 int copyflag; 630 int elt; 631 struct sk_buff *skb1, **skb_p; 632 633 /* If skb is cloned or its head is paged, reallocate 634 * head pulling out all the pages (pages are considered not writable 635 * at the moment even if they are anonymous). 636 */ 637 if ((skb_cloned(skb) || skb_shinfo(skb)->nr_frags) && 638 __pskb_pull_tail(skb, skb_pagelen(skb)-skb_headlen(skb)) == NULL) 639 return -ENOMEM; 640 641 /* Easy case. Most of packets will go this way. */ 642 if (!skb_shinfo(skb)->frag_list) { 643 /* A little of trouble, not enough of space for trailer. 644 * This should not happen, when stack is tuned to generate 645 * good frames. OK, on miss we reallocate and reserve even more 646 * space, 128 bytes is fair. */ 647 648 if (skb_tailroom(skb) < tailbits && 649 pskb_expand_head(skb, 0, tailbits-skb_tailroom(skb)+128, GFP_ATOMIC)) 650 return -ENOMEM; 651 652 /* Voila! */ 653 *trailer = skb; 654 return 1; 655 } 656 657 /* Misery. We are in troubles, going to mincer fragments... */ 658 659 elt = 1; 660 skb_p = &skb_shinfo(skb)->frag_list; 661 copyflag = 0; 662 663 while ((skb1 = *skb_p) != NULL) { 664 int ntail = 0; 665 666 /* The fragment is partially pulled by someone, 667 * this can happen on input. Copy it and everything 668 * after it. */ 669 670 if (skb_shared(skb1)) 671 copyflag = 1; 672 673 /* If the skb is the last, worry about trailer. */ 674 675 if (skb1->next == NULL && tailbits) { 676 if (skb_shinfo(skb1)->nr_frags || 677 skb_shinfo(skb1)->frag_list || 678 skb_tailroom(skb1) < tailbits) 679 ntail = tailbits + 128; 680 } 681 682 if (copyflag || 683 skb_cloned(skb1) || 684 ntail || 685 skb_shinfo(skb1)->nr_frags || 686 skb_shinfo(skb1)->frag_list) { 687 struct sk_buff *skb2; 688 689 /* Fuck, we are miserable poor guys... */ 690 if (ntail == 0) 691 skb2 = skb_copy(skb1, GFP_ATOMIC); 692 else 693 skb2 = skb_copy_expand(skb1, 694 skb_headroom(skb1), 695 ntail, 696 GFP_ATOMIC); 697 if (unlikely(skb2 == NULL)) 698 return -ENOMEM; 699 700 if (skb1->sk) 701 skb_set_owner_w(skb2, skb1->sk); 702 703 /* Looking around. Are we still alive? 704 * OK, link new skb, drop old one */ 705 706 skb2->next = skb1->next; 707 *skb_p = skb2; 708 kfree_skb(skb1); 709 skb1 = skb2; 710 } 711 elt++; 712 *trailer = skb1; 713 skb_p = &skb1->next; 714 } 715 716 return elt; 717 } 718 EXPORT_SYMBOL_GPL(skb_cow_data); 719 720 void *pskb_put(struct sk_buff *skb, struct sk_buff *tail, int len) 721 { 722 if (tail != skb) { 723 skb->data_len += len; 724 skb->len += len; 725 } 726 return skb_put(tail, len); 727 } 728 EXPORT_SYMBOL_GPL(pskb_put); 729 #endif 730