net/xfrm/xfrm_algo.c

   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