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/module.h>
  13 #include <linux/kernel.h>
  14 #include <linux/pfkeyv2.h>
  15 #include <linux/crypto.h>
  16 #include <linux/scatterlist.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
  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 aead_list[] = {
  32 {
  33         .name = "rfc4106(gcm(aes))",
  34
  35         .uinfo = {
  36                 .aead = {
  37                         .icv_truncbits = 64,
  38                 }
  39         },
  40
  41         .desc = {
  42                 .sadb_alg_id = SADB_X_EALG_AES_GCM_ICV8,
  43                 .sadb_alg_ivlen = 8,
  44                 .sadb_alg_minbits = 128,
  45                 .sadb_alg_maxbits = 256
  46         }
  47 },
  48 {
  49         .name = "rfc4106(gcm(aes))",
  50
  51         .uinfo = {
  52                 .aead = {
  53                         .icv_truncbits = 96,
  54                 }
  55         },
  56
  57         .desc = {
  58                 .sadb_alg_id = SADB_X_EALG_AES_GCM_ICV12,
  59                 .sadb_alg_ivlen = 8,
  60                 .sadb_alg_minbits = 128,
  61                 .sadb_alg_maxbits = 256
  62         }
  63 },
  64 {
  65         .name = "rfc4106(gcm(aes))",
  66
  67         .uinfo = {
  68                 .aead = {
  69                         .icv_truncbits = 128,
  70                 }
  71         },
  72
  73         .desc = {
  74                 .sadb_alg_id = SADB_X_EALG_AES_GCM_ICV16,
  75                 .sadb_alg_ivlen = 8,
  76                 .sadb_alg_minbits = 128,
  77                 .sadb_alg_maxbits = 256
  78         }
  79 },
  80 {
  81         .name = "rfc4309(ccm(aes))",
  82
  83         .uinfo = {
  84                 .aead = {
  85                         .icv_truncbits = 64,
  86                 }
  87         },
  88
  89         .desc = {
  90                 .sadb_alg_id = SADB_X_EALG_AES_CCM_ICV8,
  91                 .sadb_alg_ivlen = 8,
  92                 .sadb_alg_minbits = 128,
  93                 .sadb_alg_maxbits = 256
  94         }
  95 },
  96 {
  97         .name = "rfc4309(ccm(aes))",
  98
  99         .uinfo = {
 100                 .aead = {
 101                         .icv_truncbits = 96,
 102                 }
 103         },
 104
 105         .desc = {
 106                 .sadb_alg_id = SADB_X_EALG_AES_CCM_ICV12,
 107                 .sadb_alg_ivlen = 8,
 108                 .sadb_alg_minbits = 128,
 109                 .sadb_alg_maxbits = 256
 110         }
 111 },
 112 {
 113         .name = "rfc4309(ccm(aes))",
 114
 115         .uinfo = {
 116                 .aead = {
 117                         .icv_truncbits = 128,
 118                 }
 119         },
 120
 121         .desc = {
 122                 .sadb_alg_id = SADB_X_EALG_AES_CCM_ICV16,
 123                 .sadb_alg_ivlen = 8,
 124                 .sadb_alg_minbits = 128,
 125                 .sadb_alg_maxbits = 256
 126         }
 127 },
 128 };
 129
 130 static struct xfrm_algo_desc aalg_list[] = {
 131 {
 132         .name = "digest_null",
 133
 134         .uinfo = {
 135                 .auth = {
 136                         .icv_truncbits = 0,
 137                         .icv_fullbits = 0,
 138                 }
 139         },
 140
 141         .desc = {
 142                 .sadb_alg_id = SADB_X_AALG_NULL,
 143                 .sadb_alg_ivlen = 0,
 144                 .sadb_alg_minbits = 0,
 145                 .sadb_alg_maxbits = 0
 146         }
 147 },
 148 {
 149         .name = "hmac(md5)",
 150         .compat = "md5",
 151
 152         .uinfo = {
 153                 .auth = {
 154                         .icv_truncbits = 96,
 155                         .icv_fullbits = 128,
 156                 }
 157         },
 158
 159         .desc = {
 160                 .sadb_alg_id = SADB_AALG_MD5HMAC,
 161                 .sadb_alg_ivlen = 0,
 162                 .sadb_alg_minbits = 128,
 163                 .sadb_alg_maxbits = 128
 164         }
 165 },
 166 {
 167         .name = "hmac(sha1)",
 168         .compat = "sha1",
 169
 170         .uinfo = {
 171                 .auth = {
 172                         .icv_truncbits = 96,
 173                         .icv_fullbits = 160,
 174                 }
 175         },
 176
 177         .desc = {
 178                 .sadb_alg_id = SADB_AALG_SHA1HMAC,
 179                 .sadb_alg_ivlen = 0,
 180                 .sadb_alg_minbits = 160,
 181                 .sadb_alg_maxbits = 160
 182         }
 183 },
 184 {
 185         .name = "hmac(sha256)",
 186         .compat = "sha256",
 187
 188         .uinfo = {
 189                 .auth = {
 190                         .icv_truncbits = 96,
 191                         .icv_fullbits = 256,
 192                 }
 193         },
 194
 195         .desc = {
 196                 .sadb_alg_id = SADB_X_AALG_SHA2_256HMAC,
 197                 .sadb_alg_ivlen = 0,
 198                 .sadb_alg_minbits = 256,
 199                 .sadb_alg_maxbits = 256
 200         }
 201 },
 202 {
 203         .name = "hmac(sha384)",
 204
 205         .uinfo = {
 206                 .auth = {
 207                         .icv_truncbits = 192,
 208                         .icv_fullbits = 384,
 209                 }
 210         },
 211
 212         .desc = {
 213                 .sadb_alg_id = SADB_X_AALG_SHA2_384HMAC,
 214                 .sadb_alg_ivlen = 0,
 215                 .sadb_alg_minbits = 384,
 216                 .sadb_alg_maxbits = 384
 217         }
 218 },
 219 {
 220         .name = "hmac(sha512)",
 221
 222         .uinfo = {
 223                 .auth = {
 224                         .icv_truncbits = 256,
 225                         .icv_fullbits = 512,
 226                 }
 227         },
 228
 229         .desc = {
 230                 .sadb_alg_id = SADB_X_AALG_SHA2_512HMAC,
 231                 .sadb_alg_ivlen = 0,
 232                 .sadb_alg_minbits = 512,
 233                 .sadb_alg_maxbits = 512
 234         }
 235 },
 236 {
 237         .name = "hmac(rmd160)",
 238         .compat = "rmd160",
 239
 240         .uinfo = {
 241                 .auth = {
 242                         .icv_truncbits = 96,
 243                         .icv_fullbits = 160,
 244                 }
 245         },
 246
 247         .desc = {
 248                 .sadb_alg_id = SADB_X_AALG_RIPEMD160HMAC,
 249                 .sadb_alg_ivlen = 0,
 250                 .sadb_alg_minbits = 160,
 251                 .sadb_alg_maxbits = 160
 252         }
 253 },
 254 {
 255         .name = "xcbc(aes)",
 256
 257         .uinfo = {
 258                 .auth = {
 259                         .icv_truncbits = 96,
 260                         .icv_fullbits = 128,
 261                 }
 262         },
 263
 264         .desc = {
 265                 .sadb_alg_id = SADB_X_AALG_AES_XCBC_MAC,
 266                 .sadb_alg_ivlen = 0,
 267                 .sadb_alg_minbits = 128,
 268                 .sadb_alg_maxbits = 128
 269         }
 270 },
 271 };
 272
 273 static struct xfrm_algo_desc ealg_list[] = {
 274 {
 275         .name = "ecb(cipher_null)",
 276         .compat = "cipher_null",
 277
 278         .uinfo = {
 279                 .encr = {
 280                         .blockbits = 8,
 281                         .defkeybits = 0,
 282                 }
 283         },
 284
 285         .desc = {
 286                 .sadb_alg_id =  SADB_EALG_NULL,
 287                 .sadb_alg_ivlen = 0,
 288                 .sadb_alg_minbits = 0,
 289                 .sadb_alg_maxbits = 0
 290         }
 291 },
 292 {
 293         .name = "cbc(des)",
 294         .compat = "des",
 295
 296         .uinfo = {
 297                 .encr = {
 298                         .blockbits = 64,
 299                         .defkeybits = 64,
 300                 }
 301         },
 302
 303         .desc = {
 304                 .sadb_alg_id = SADB_EALG_DESCBC,
 305                 .sadb_alg_ivlen = 8,
 306                 .sadb_alg_minbits = 64,
 307                 .sadb_alg_maxbits = 64
 308         }
 309 },
 310 {
 311         .name = "cbc(des3_ede)",
 312         .compat = "des3_ede",
 313
 314         .uinfo = {
 315                 .encr = {
 316                         .blockbits = 64,
 317                         .defkeybits = 192,
 318                 }
 319         },
 320
 321         .desc = {
 322                 .sadb_alg_id = SADB_EALG_3DESCBC,
 323                 .sadb_alg_ivlen = 8,
 324                 .sadb_alg_minbits = 192,
 325                 .sadb_alg_maxbits = 192
 326         }
 327 },
 328 {
 329         .name = "cbc(cast5)",
 330         .compat = "cast5",
 331
 332         .uinfo = {
 333                 .encr = {
 334                         .blockbits = 64,
 335                         .defkeybits = 128,
 336                 }
 337         },
 338
 339         .desc = {
 340                 .sadb_alg_id = SADB_X_EALG_CASTCBC,
 341                 .sadb_alg_ivlen = 8,
 342                 .sadb_alg_minbits = 40,
 343                 .sadb_alg_maxbits = 128
 344         }
 345 },
 346 {
 347         .name = "cbc(blowfish)",
 348         .compat = "blowfish",
 349
 350         .uinfo = {
 351                 .encr = {
 352                         .blockbits = 64,
 353                         .defkeybits = 128,
 354                 }
 355         },
 356
 357         .desc = {
 358                 .sadb_alg_id = SADB_X_EALG_BLOWFISHCBC,
 359                 .sadb_alg_ivlen = 8,
 360                 .sadb_alg_minbits = 40,
 361                 .sadb_alg_maxbits = 448
 362         }
 363 },
 364 {
 365         .name = "cbc(aes)",
 366         .compat = "aes",
 367
 368         .uinfo = {
 369                 .encr = {
 370                         .blockbits = 128,
 371                         .defkeybits = 128,
 372                 }
 373         },
 374
 375         .desc = {
 376                 .sadb_alg_id = SADB_X_EALG_AESCBC,
 377                 .sadb_alg_ivlen = 8,
 378                 .sadb_alg_minbits = 128,
 379                 .sadb_alg_maxbits = 256
 380         }
 381 },
 382 {
 383         .name = "cbc(serpent)",
 384         .compat = "serpent",
 385
 386         .uinfo = {
 387                 .encr = {
 388                         .blockbits = 128,
 389                         .defkeybits = 128,
 390                 }
 391         },
 392
 393         .desc = {
 394                 .sadb_alg_id = SADB_X_EALG_SERPENTCBC,
 395                 .sadb_alg_ivlen = 8,
 396                 .sadb_alg_minbits = 128,
 397                 .sadb_alg_maxbits = 256,
 398         }
 399 },
 400 {
 401         .name = "cbc(camellia)",
 402         .compat = "camellia",
 403
 404         .uinfo = {
 405                 .encr = {
 406                         .blockbits = 128,
 407                         .defkeybits = 128,
 408                 }
 409         },
 410
 411         .desc = {
 412                 .sadb_alg_id = SADB_X_EALG_CAMELLIACBC,
 413                 .sadb_alg_ivlen = 8,
 414                 .sadb_alg_minbits = 128,
 415                 .sadb_alg_maxbits = 256
 416         }
 417 },
 418 {
 419         .name = "cbc(twofish)",
 420         .compat = "twofish",
 421
 422         .uinfo = {
 423                 .encr = {
 424                         .blockbits = 128,
 425                         .defkeybits = 128,
 426                 }
 427         },
 428
 429         .desc = {
 430                 .sadb_alg_id = SADB_X_EALG_TWOFISHCBC,
 431                 .sadb_alg_ivlen = 8,
 432                 .sadb_alg_minbits = 128,
 433                 .sadb_alg_maxbits = 256
 434         }
 435 },
 436 {
 437         .name = "rfc3686(ctr(aes))",
 438
 439         .uinfo = {
 440                 .encr = {
 441                         .blockbits = 128,
 442                         .defkeybits = 160, /* 128-bit key + 32-bit nonce */
 443                 }
 444         },
 445
 446         .desc = {
 447                 .sadb_alg_id = SADB_X_EALG_AESCTR,
 448                 .sadb_alg_ivlen = 8,
 449                 .sadb_alg_minbits = 128,
 450                 .sadb_alg_maxbits = 256
 451         }
 452 },
 453 };
 454
 455 static struct xfrm_algo_desc calg_list[] = {
 456 {
 457         .name = "deflate",
 458         .uinfo = {
 459                 .comp = {
 460                         .threshold = 90,
 461                 }
 462         },
 463         .desc = { .sadb_alg_id = SADB_X_CALG_DEFLATE }
 464 },
 465 {
 466         .name = "lzs",
 467         .uinfo = {
 468                 .comp = {
 469                         .threshold = 90,
 470                 }
 471         },
 472         .desc = { .sadb_alg_id = SADB_X_CALG_LZS }
 473 },
 474 {
 475         .name = "lzjh",
 476         .uinfo = {
 477                 .comp = {
 478                         .threshold = 50,
 479                 }
 480         },
 481         .desc = { .sadb_alg_id = SADB_X_CALG_LZJH }
 482 },
 483 };
 484
 485 static inline int aead_entries(void)
 486 {
 487         return ARRAY_SIZE(aead_list);
 488 }
 489
 490 static inline int aalg_entries(void)
 491 {
 492         return ARRAY_SIZE(aalg_list);
 493 }
 494
 495 static inline int ealg_entries(void)
 496 {
 497         return ARRAY_SIZE(ealg_list);
 498 }
 499
 500 static inline int calg_entries(void)
 501 {
 502         return ARRAY_SIZE(calg_list);
 503 }
 504
 505 struct xfrm_algo_list {
 506         struct xfrm_algo_desc *algs;
 507         int entries;
 508         u32 type;
 509         u32 mask;
 510 };
 511
 512 static const struct xfrm_algo_list xfrm_aead_list = {
 513         .algs = aead_list,
 514         .entries = ARRAY_SIZE(aead_list),
 515         .type = CRYPTO_ALG_TYPE_AEAD,
 516         .mask = CRYPTO_ALG_TYPE_MASK,
 517 };
 518
 519 static const struct xfrm_algo_list xfrm_aalg_list = {
 520         .algs = aalg_list,
 521         .entries = ARRAY_SIZE(aalg_list),
 522         .type = CRYPTO_ALG_TYPE_HASH,
 523         .mask = CRYPTO_ALG_TYPE_HASH_MASK,
 524 };
 525
 526 static const struct xfrm_algo_list xfrm_ealg_list = {
 527         .algs = ealg_list,
 528         .entries = ARRAY_SIZE(ealg_list),
 529         .type = CRYPTO_ALG_TYPE_BLKCIPHER,
 530         .mask = CRYPTO_ALG_TYPE_BLKCIPHER_MASK,
 531 };
 532
 533 static const struct xfrm_algo_list xfrm_calg_list = {
 534         .algs = calg_list,
 535         .entries = ARRAY_SIZE(calg_list),
 536         .type = CRYPTO_ALG_TYPE_COMPRESS,
 537         .mask = CRYPTO_ALG_TYPE_MASK,
 538 };
 539
 540 static struct xfrm_algo_desc *xfrm_find_algo(
 541         const struct xfrm_algo_list *algo_list,
 542         int match(const struct xfrm_algo_desc *entry, const void *data),
 543         const void *data, int probe)
 544 {
 545         struct xfrm_algo_desc *list = algo_list->algs;
 546         int i, status;
 547
 548         for (i = 0; i < algo_list->entries; i++) {
 549                 if (!match(list + i, data))
 550                         continue;
 551
 552                 if (list[i].available)
 553                         return &list[i];
 554
 555                 if (!probe)
 556                         break;
 557
 558                 status = crypto_has_alg(list[i].name, algo_list->type,
 559                                         algo_list->mask);
 560                 if (!status)
 561                         break;
 562
 563                 list[i].available = status;
 564                 return &list[i];
 565         }
 566         return NULL;
 567 }
 568
 569 static int xfrm_alg_id_match(const struct xfrm_algo_desc *entry,
 570                              const void *data)
 571 {
 572         return entry->desc.sadb_alg_id == (unsigned long)data;
 573 }
 574
 575 struct xfrm_algo_desc *xfrm_aalg_get_byid(int alg_id)
 576 {
 577         return xfrm_find_algo(&xfrm_aalg_list, xfrm_alg_id_match,
 578                               (void *)(unsigned long)alg_id, 1);
 579 }
 580 EXPORT_SYMBOL_GPL(xfrm_aalg_get_byid);
 581
 582 struct xfrm_algo_desc *xfrm_ealg_get_byid(int alg_id)
 583 {
 584         return xfrm_find_algo(&xfrm_ealg_list, xfrm_alg_id_match,
 585                               (void *)(unsigned long)alg_id, 1);
 586 }
 587 EXPORT_SYMBOL_GPL(xfrm_ealg_get_byid);
 588
 589 struct xfrm_algo_desc *xfrm_calg_get_byid(int alg_id)
 590 {
 591         return xfrm_find_algo(&xfrm_calg_list, xfrm_alg_id_match,
 592                               (void *)(unsigned long)alg_id, 1);
 593 }
 594 EXPORT_SYMBOL_GPL(xfrm_calg_get_byid);
 595
 596 static int xfrm_alg_name_match(const struct xfrm_algo_desc *entry,
 597                                const void *data)
 598 {
 599         const char *name = data;
 600
 601         return name && (!strcmp(name, entry->name) ||
 602                         (entry->compat && !strcmp(name, entry->compat)));
 603 }
 604
 605 struct xfrm_algo_desc *xfrm_aalg_get_byname(char *name, int probe)
 606 {
 607         return xfrm_find_algo(&xfrm_aalg_list, xfrm_alg_name_match, name,
 608                               probe);
 609 }
 610 EXPORT_SYMBOL_GPL(xfrm_aalg_get_byname);
 611
 612 struct xfrm_algo_desc *xfrm_ealg_get_byname(char *name, int probe)
 613 {
 614         return xfrm_find_algo(&xfrm_ealg_list, xfrm_alg_name_match, name,
 615                               probe);
 616 }
 617 EXPORT_SYMBOL_GPL(xfrm_ealg_get_byname);
 618
 619 struct xfrm_algo_desc *xfrm_calg_get_byname(char *name, int probe)
 620 {
 621         return xfrm_find_algo(&xfrm_calg_list, xfrm_alg_name_match, name,
 622                               probe);
 623 }
 624 EXPORT_SYMBOL_GPL(xfrm_calg_get_byname);
 625
 626 struct xfrm_aead_name {
 627         const char *name;
 628         int icvbits;
 629 };
 630
 631 static int xfrm_aead_name_match(const struct xfrm_algo_desc *entry,
 632                                 const void *data)
 633 {
 634         const struct xfrm_aead_name *aead = data;
 635         const char *name = aead->name;
 636
 637         return aead->icvbits == entry->uinfo.aead.icv_truncbits && name &&
 638                !strcmp(name, entry->name);
 639 }
 640
 641 struct xfrm_algo_desc *xfrm_aead_get_byname(char *name, int icv_len, int probe)
 642 {
 643         struct xfrm_aead_name data = {
 644                 .name = name,
 645                 .icvbits = icv_len,
 646         };
 647
 648         return xfrm_find_algo(&xfrm_aead_list, xfrm_aead_name_match, &data,
 649                               probe);
 650 }
 651 EXPORT_SYMBOL_GPL(xfrm_aead_get_byname);
 652
 653 struct xfrm_algo_desc *xfrm_aalg_get_byidx(unsigned int idx)
 654 {
 655         if (idx >= aalg_entries())
 656                 return NULL;
 657
 658         return &aalg_list[idx];
 659 }
 660 EXPORT_SYMBOL_GPL(xfrm_aalg_get_byidx);
 661
 662 struct xfrm_algo_desc *xfrm_ealg_get_byidx(unsigned int idx)
 663 {
 664         if (idx >= ealg_entries())
 665                 return NULL;
 666
 667         return &ealg_list[idx];
 668 }
 669 EXPORT_SYMBOL_GPL(xfrm_ealg_get_byidx);
 670
 671 /*
 672  * Probe for the availability of crypto algorithms, and set the available
 673  * flag for any algorithms found on the system.  This is typically called by
 674  * pfkey during userspace SA add, update or register.
 675  */
 676 void xfrm_probe_algs(void)
 677 {
 678         int i, status;
 679
 680         BUG_ON(in_softirq());
 681
 682         for (i = 0; i < aalg_entries(); i++) {
 683                 status = crypto_has_hash(aalg_list[i].name, 0,
 684                                          CRYPTO_ALG_ASYNC);
 685                 if (aalg_list[i].available != status)
 686                         aalg_list[i].available = status;
 687         }
 688
 689         for (i = 0; i < ealg_entries(); i++) {
 690                 status = crypto_has_blkcipher(ealg_list[i].name, 0,
 691                                               CRYPTO_ALG_ASYNC);
 692                 if (ealg_list[i].available != status)
 693                         ealg_list[i].available = status;
 694         }
 695
 696         for (i = 0; i < calg_entries(); i++) {
 697                 status = crypto_has_comp(calg_list[i].name, 0,
 698                                          CRYPTO_ALG_ASYNC);
 699                 if (calg_list[i].available != status)
 700                         calg_list[i].available = status;
 701         }
 702 }
 703 EXPORT_SYMBOL_GPL(xfrm_probe_algs);
 704
 705 int xfrm_count_auth_supported(void)
 706 {
 707         int i, n;
 708
 709         for (i = 0, n = 0; i < aalg_entries(); i++)
 710                 if (aalg_list[i].available)
 711                         n++;
 712         return n;
 713 }
 714 EXPORT_SYMBOL_GPL(xfrm_count_auth_supported);
 715
 716 int xfrm_count_enc_supported(void)
 717 {
 718         int i, n;
 719
 720         for (i = 0, n = 0; i < ealg_entries(); i++)
 721                 if (ealg_list[i].available)
 722                         n++;
 723         return n;
 724 }
 725 EXPORT_SYMBOL_GPL(xfrm_count_enc_supported);
 726
 727 #if defined(CONFIG_INET_ESP) || defined(CONFIG_INET_ESP_MODULE) || defined(CONFIG_INET6_ESP) || defined(CONFIG_INET6_ESP_MODULE)
 728
 729 void *pskb_put(struct sk_buff *skb, struct sk_buff *tail, int len)
 730 {
 731         if (tail != skb) {
 732                 skb->data_len += len;
 733                 skb->len += len;
 734         }
 735         return skb_put(tail, len);
 736 }
 737 EXPORT_SYMBOL_GPL(pskb_put);
 738 #endif