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