sys/opencrypto/xform.c

   1 /*      $FreeBSD: src/sys/opencrypto/xform.c,v 1.10 2008/10/23 15:53:51 des Exp $       */
   2 /*      $OpenBSD: xform.c,v 1.16 2001/08/28 12:20:43 ben Exp $  */
   3 /*-
   4  * The authors of this code are John Ioannidis (ji@tla.org),
   5  * Angelos D. Keromytis (kermit@csd.uch.gr) and
   6  * Niels Provos (provos@physnet.uni-hamburg.de).
   7  *
   8  * This code was written by John Ioannidis for BSD/OS in Athens, Greece,
   9  * in November 1995.
  10  *
  11  * Ported to OpenBSD and NetBSD, with additional transforms, in December 1996,
  12  * by Angelos D. Keromytis.
  13  *
  14  * Additional transforms and features in 1997 and 1998 by Angelos D. Keromytis
  15  * and Niels Provos.
  16  *
  17  * Additional features in 1999 by Angelos D. Keromytis.
  18  *
  19  * Copyright (C) 1995, 1996, 1997, 1998, 1999 by John Ioannidis,
  20  * Angelos D. Keromytis and Niels Provos.
  21  *
  22  * Copyright (C) 2001, Angelos D. Keromytis.
  23  *
  24  * Permission to use, copy, and modify this software with or without fee
  25  * is hereby granted, provided that this entire notice is included in
  26  * all copies of any software which is or includes a copy or
  27  * modification of this software.
  28  * You may use this code under the GNU public license if you so wish. Please
  29  * contribute changes back to the authors under this freer than GPL license
  30  * so that we may further the use of strong encryption without limitations to
  31  * all.
  32  *
  33  * THIS SOFTWARE IS BEING PROVIDED "AS IS", WITHOUT ANY EXPRESS OR
  34  * IMPLIED WARRANTY. IN PARTICULAR, NONE OF THE AUTHORS MAKES ANY
  35  * REPRESENTATION OR WARRANTY OF ANY KIND CONCERNING THE
  36  * MERCHANTABILITY OF THIS SOFTWARE OR ITS FITNESS FOR ANY PARTICULAR
  37  * PURPOSE.
  38  */
  39
  40 #include <sys/param.h>
  41 #include <sys/systm.h>
  42 #include <sys/malloc.h>
  43 #include <sys/sysctl.h>
  44 #include <sys/errno.h>
  45 #include <sys/time.h>
  46 #include <sys/kernel.h>
  47 #include <machine/cpu.h>
  48
  49 #include <crypto/blowfish/blowfish.h>
  50 #include <crypto/des/des.h>
  51 #include <crypto/rijndael/rijndael.h>
  52 #include <crypto/camellia/camellia.h>
  53 #include <crypto/sha1.h>
  54
  55 #include <opencrypto/cast.h>
  56 #include <opencrypto/deflate.h>
  57 #include <opencrypto/rmd160.h>
  58 #include <opencrypto/skipjack.h>
  59
  60 #include <sys/md5.h>
  61
  62 #include <opencrypto/cryptodev.h>
  63 #include <opencrypto/xform.h>
  64
  65 static void null_encrypt(caddr_t, u_int8_t *);
  66 static void null_decrypt(caddr_t, u_int8_t *);
  67 static int null_setkey(u_int8_t **, u_int8_t *, int);
  68 static void null_zerokey(u_int8_t **);
  69
  70 static  int des1_setkey(u_int8_t **, u_int8_t *, int);
  71 static  int des3_setkey(u_int8_t **, u_int8_t *, int);
  72 static  int blf_setkey(u_int8_t **, u_int8_t *, int);
  73 static  int cast5_setkey(u_int8_t **, u_int8_t *, int);
  74 static  int skipjack_setkey(u_int8_t **, u_int8_t *, int);
  75 static  int rijndael128_setkey(u_int8_t **, u_int8_t *, int);
  76 static  int aes_xts_setkey(u_int8_t **, u_int8_t *, int);
  77 static  int aes_ctr_setkey(u_int8_t **, u_int8_t *, int);
  78 static  int cml_setkey(u_int8_t **, u_int8_t *, int);
  79 static  void des1_encrypt(caddr_t, u_int8_t *);
  80 static  void des3_encrypt(caddr_t, u_int8_t *);
  81 static  void blf_encrypt(caddr_t, u_int8_t *);
  82 static  void cast5_encrypt(caddr_t, u_int8_t *);
  83 static  void skipjack_encrypt(caddr_t, u_int8_t *);
  84 static  void rijndael128_encrypt(caddr_t, u_int8_t *);
  85 static  void aes_xts_encrypt(caddr_t, u_int8_t *);
  86 static  void cml_encrypt(caddr_t, u_int8_t *);
  87 static  void des1_decrypt(caddr_t, u_int8_t *);
  88 static  void des3_decrypt(caddr_t, u_int8_t *);
  89 static  void blf_decrypt(caddr_t, u_int8_t *);
  90 static  void cast5_decrypt(caddr_t, u_int8_t *);
  91 static  void skipjack_decrypt(caddr_t, u_int8_t *);
  92 static  void rijndael128_decrypt(caddr_t, u_int8_t *);
  93 static  void aes_xts_decrypt(caddr_t, u_int8_t *);
  94 static  void cml_decrypt(caddr_t, u_int8_t *);
  95 static  void des1_zerokey(u_int8_t **);
  96 static  void des3_zerokey(u_int8_t **);
  97 static  void blf_zerokey(u_int8_t **);
  98 static  void cast5_zerokey(u_int8_t **);
  99 static  void skipjack_zerokey(u_int8_t **);
 100 static  void rijndael128_zerokey(u_int8_t **);
 101 static  void aes_xts_zerokey(u_int8_t **);
 102 static  void aes_ctr_zerokey(u_int8_t **);
 103 static  void cml_zerokey(u_int8_t **);
 104
 105 static  void aes_ctr_crypt(caddr_t, u_int8_t *);
 106
 107 static  void aes_ctr_reinit(caddr_t, u_int8_t *);
 108 static  void aes_xts_reinit(caddr_t, u_int8_t *);
 109
 110 static  void null_init(void *);
 111 static  int null_update(void *, u_int8_t *, u_int16_t);
 112 static  void null_final(u_int8_t *, void *);
 113 static  int MD5Update_int(void *, u_int8_t *, u_int16_t);
 114 static  void SHA1Init_int(void *);
 115 static  int SHA1Update_int(void *, u_int8_t *, u_int16_t);
 116 static  void SHA1Final_int(u_int8_t *, void *);
 117 static  int RMD160Update_int(void *, u_int8_t *, u_int16_t);
 118 static  int SHA256Update_int(void *, u_int8_t *, u_int16_t);
 119 static  int SHA384Update_int(void *, u_int8_t *, u_int16_t);
 120 static  int SHA512Update_int(void *, u_int8_t *, u_int16_t);
 121
 122 static  u_int32_t deflate_compress(u_int8_t *, u_int32_t, u_int8_t **);
 123 static  u_int32_t deflate_decompress(u_int8_t *, u_int32_t, u_int8_t **);
 124
 125 /* Helper */
 126 struct aes_xts_ctx;
 127 static void aes_xts_crypt(struct aes_xts_ctx *, u_int8_t *, u_int);
 128
 129 MALLOC_DEFINE(M_XDATA, "xform", "xform data buffers");
 130
 131 /* Encryption instances */
 132 struct enc_xform enc_xform_null = {
 133         CRYPTO_NULL_CBC, "NULL",
 134         /* NB: blocksize of 4 is to generate a properly aligned ESP header */
 135         NULL_BLOCK_LEN, NULL_BLOCK_LEN, 0, 256, /* 2048 bits, max key */
 136         null_encrypt,
 137         null_decrypt,
 138         null_setkey,
 139         null_zerokey,
 140         NULL
 141 };
 142
 143 struct enc_xform enc_xform_des = {
 144         CRYPTO_DES_CBC, "DES",
 145         DES_BLOCK_LEN, DES_BLOCK_LEN, 8, 8,
 146         des1_encrypt,
 147         des1_decrypt,
 148         des1_setkey,
 149         des1_zerokey,
 150         NULL
 151 };
 152
 153 struct enc_xform enc_xform_3des = {
 154         CRYPTO_3DES_CBC, "3DES",
 155         DES3_BLOCK_LEN, DES3_BLOCK_LEN, 24, 24,
 156         des3_encrypt,
 157         des3_decrypt,
 158         des3_setkey,
 159         des3_zerokey,
 160         NULL
 161 };
 162
 163 struct enc_xform enc_xform_blf = {
 164         CRYPTO_BLF_CBC, "Blowfish",
 165         BLOWFISH_BLOCK_LEN, BLOWFISH_BLOCK_LEN, 5, 56 /* 448 bits, max key */,
 166         blf_encrypt,
 167         blf_decrypt,
 168         blf_setkey,
 169         blf_zerokey,
 170         NULL
 171 };
 172
 173 struct enc_xform enc_xform_cast5 = {
 174         CRYPTO_CAST_CBC, "CAST-128",
 175         CAST128_BLOCK_LEN, CAST128_BLOCK_LEN, 5, 16,
 176         cast5_encrypt,
 177         cast5_decrypt,
 178         cast5_setkey,
 179         cast5_zerokey,
 180         NULL
 181 };
 182
 183 struct enc_xform enc_xform_skipjack = {
 184         CRYPTO_SKIPJACK_CBC, "Skipjack",
 185         SKIPJACK_BLOCK_LEN, SKIPJACK_BLOCK_LEN, 10, 10,
 186         skipjack_encrypt,
 187         skipjack_decrypt,
 188         skipjack_setkey,
 189         skipjack_zerokey,
 190         NULL
 191 };
 192
 193 struct enc_xform enc_xform_rijndael128 = {
 194         CRYPTO_RIJNDAEL128_CBC, "Rijndael-128/AES",
 195         RIJNDAEL128_BLOCK_LEN, RIJNDAEL128_BLOCK_LEN, 8, 32,
 196         rijndael128_encrypt,
 197         rijndael128_decrypt,
 198         rijndael128_setkey,
 199         rijndael128_zerokey,
 200         NULL
 201 };
 202
 203 struct enc_xform enc_xform_aes_xts = {
 204         CRYPTO_AES_XTS, "AES-XTS",
 205         AES_XTS_BLOCK_LEN, AES_XTS_IV_LEN, 32, 64,
 206         aes_xts_encrypt,
 207         aes_xts_decrypt,
 208         aes_xts_setkey,
 209         aes_xts_zerokey,
 210         aes_xts_reinit
 211 };
 212
 213 struct enc_xform enc_xform_aes_ctr = {
 214         CRYPTO_AES_CTR, "AES-CTR",
 215         AESCTR_BLOCK_LEN, AESCTR_IV_LEN, 16+4, 32+4,
 216         aes_ctr_crypt,
 217         aes_ctr_crypt,
 218         aes_ctr_setkey,
 219         aes_ctr_zerokey,
 220         aes_ctr_reinit
 221 };
 222
 223 struct enc_xform enc_xform_arc4 = {
 224         CRYPTO_ARC4, "ARC4",
 225         1, 1, 1, 32,
 226         NULL,
 227         NULL,
 228         NULL,
 229         NULL,
 230         NULL
 231 };
 232
 233 struct enc_xform enc_xform_camellia = {
 234         CRYPTO_CAMELLIA_CBC, "Camellia",
 235         CAMELLIA_BLOCK_LEN, CAMELLIA_BLOCK_LEN, 8, 32,
 236         cml_encrypt,
 237         cml_decrypt,
 238         cml_setkey,
 239         cml_zerokey,
 240         NULL
 241 };
 242
 243 /* Authentication instances */
 244 struct auth_hash auth_hash_null = {
 245         CRYPTO_NULL_HMAC, "NULL-HMAC",
 246         0, NULL_HASH_LEN, NULL_HMAC_BLOCK_LEN, sizeof(int),     /* NB: context isn't used */
 247         null_init, null_update, null_final
 248 };
 249
 250 struct auth_hash auth_hash_hmac_md5 = {
 251         CRYPTO_MD5_HMAC, "HMAC-MD5",
 252         16, MD5_HASH_LEN, MD5_HMAC_BLOCK_LEN, sizeof(MD5_CTX),
 253         (void (*) (void *)) MD5Init, MD5Update_int,
 254         (void (*) (u_int8_t *, void *)) MD5Final
 255 };
 256
 257 struct auth_hash auth_hash_hmac_sha1 = {
 258         CRYPTO_SHA1_HMAC, "HMAC-SHA1",
 259         20, SHA1_HASH_LEN, SHA1_HMAC_BLOCK_LEN, sizeof(SHA1_CTX),
 260         SHA1Init_int, SHA1Update_int, SHA1Final_int
 261 };
 262
 263 struct auth_hash auth_hash_hmac_ripemd_160 = {
 264         CRYPTO_RIPEMD160_HMAC, "HMAC-RIPEMD-160",
 265         20, RIPEMD160_HASH_LEN, RIPEMD160_HMAC_BLOCK_LEN, sizeof(RMD160_CTX),
 266         (void (*)(void *)) RMD160Init, RMD160Update_int,
 267         (void (*)(u_int8_t *, void *)) RMD160Final
 268 };
 269
 270 struct auth_hash auth_hash_key_md5 = {
 271         CRYPTO_MD5_KPDK, "Keyed MD5",
 272         0, MD5_KPDK_HASH_LEN, 0, sizeof(MD5_CTX),
 273         (void (*)(void *)) MD5Init, MD5Update_int,
 274         (void (*)(u_int8_t *, void *)) MD5Final
 275 };
 276
 277 struct auth_hash auth_hash_key_sha1 = {
 278         CRYPTO_SHA1_KPDK, "Keyed SHA1",
 279         0, SHA1_KPDK_HASH_LEN, 0, sizeof(SHA1_CTX),
 280         SHA1Init_int, SHA1Update_int, SHA1Final_int
 281 };
 282
 283 struct auth_hash auth_hash_hmac_sha2_256 = {
 284         CRYPTO_SHA2_256_HMAC, "HMAC-SHA2-256",
 285         32, SHA2_256_HASH_LEN, SHA2_256_HMAC_BLOCK_LEN, sizeof(SHA256_CTX),
 286         (void (*)(void *)) SHA256_Init, SHA256Update_int,
 287         (void (*)(u_int8_t *, void *)) SHA256_Final
 288 };
 289
 290 struct auth_hash auth_hash_hmac_sha2_384 = {
 291         CRYPTO_SHA2_384_HMAC, "HMAC-SHA2-384",
 292         48, SHA2_384_HASH_LEN, SHA2_384_HMAC_BLOCK_LEN, sizeof(SHA384_CTX),
 293         (void (*)(void *)) SHA384_Init, SHA384Update_int,
 294         (void (*)(u_int8_t *, void *)) SHA384_Final
 295 };
 296
 297 struct auth_hash auth_hash_hmac_sha2_512 = {
 298         CRYPTO_SHA2_512_HMAC, "HMAC-SHA2-512",
 299         64, SHA2_512_HASH_LEN, SHA2_512_HMAC_BLOCK_LEN, sizeof(SHA512_CTX),
 300         (void (*)(void *)) SHA512_Init, SHA512Update_int,
 301         (void (*)(u_int8_t *, void *)) SHA512_Final
 302 };
 303
 304 /* Compression instance */
 305 struct comp_algo comp_algo_deflate = {
 306         CRYPTO_DEFLATE_COMP, "Deflate",
 307         90, deflate_compress,
 308         deflate_decompress
 309 };
 310
 311 /*
 312  * Encryption wrapper routines.
 313  */
 314 static void
 315 null_encrypt(caddr_t key, u_int8_t *blk)
 316 {
 317 }
 318 static void
 319 null_decrypt(caddr_t key, u_int8_t *blk)
 320 {
 321 }
 322 static int
 323 null_setkey(u_int8_t **sched, u_int8_t *key, int len)
 324 {
 325         *sched = NULL;
 326         return 0;
 327 }
 328 static void
 329 null_zerokey(u_int8_t **sched)
 330 {
 331         *sched = NULL;
 332 }
 333
 334 static void
 335 des1_encrypt(caddr_t key, u_int8_t *blk)
 336 {
 337         des_cblock *cb = (des_cblock *) blk;
 338         des_key_schedule *p = (des_key_schedule *) key;
 339
 340         des_ecb_encrypt(cb, cb, p[0], DES_ENCRYPT);
 341 }
 342
 343 static void
 344 des1_decrypt(caddr_t key, u_int8_t *blk)
 345 {
 346         des_cblock *cb = (des_cblock *) blk;
 347         des_key_schedule *p = (des_key_schedule *) key;
 348
 349         des_ecb_encrypt(cb, cb, p[0], DES_DECRYPT);
 350 }
 351
 352 static int
 353 des1_setkey(u_int8_t **sched, u_int8_t *key, int len)
 354 {
 355         des_key_schedule *p;
 356         int err;
 357
 358         p = kmalloc(sizeof (des_key_schedule),
 359                     M_CRYPTO_DATA, M_INTWAIT | M_ZERO);
 360         if (p != NULL) {
 361                 des_set_key((des_cblock *) key, p[0]);
 362                 err = 0;
 363         } else
 364                 err = ENOMEM;
 365         *sched = (u_int8_t *) p;
 366         return err;
 367 }
 368
 369 static void
 370 des1_zerokey(u_int8_t **sched)
 371 {
 372         bzero(*sched, sizeof (des_key_schedule));
 373         kfree(*sched, M_CRYPTO_DATA);
 374         *sched = NULL;
 375 }
 376
 377 static void
 378 des3_encrypt(caddr_t key, u_int8_t *blk)
 379 {
 380         des_cblock *cb = (des_cblock *) blk;
 381         des_key_schedule *p = (des_key_schedule *) key;
 382
 383         des_ecb3_encrypt(cb, cb, p[0], p[1], p[2], DES_ENCRYPT);
 384 }
 385
 386 static void
 387 des3_decrypt(caddr_t key, u_int8_t *blk)
 388 {
 389         des_cblock *cb = (des_cblock *) blk;
 390         des_key_schedule *p = (des_key_schedule *) key;
 391
 392         des_ecb3_encrypt(cb, cb, p[0], p[1], p[2], DES_DECRYPT);
 393 }
 394
 395 static int
 396 des3_setkey(u_int8_t **sched, u_int8_t *key, int len)
 397 {
 398         des_key_schedule *p;
 399         int err;
 400
 401         p = kmalloc(3 * sizeof(des_key_schedule),
 402                     M_CRYPTO_DATA, M_INTWAIT | M_ZERO);
 403         if (p != NULL) {
 404                 des_set_key((des_cblock *)(key +  0), p[0]);
 405                 des_set_key((des_cblock *)(key +  8), p[1]);
 406                 des_set_key((des_cblock *)(key + 16), p[2]);
 407                 err = 0;
 408         } else
 409                 err = ENOMEM;
 410         *sched = (u_int8_t *) p;
 411         return err;
 412 }
 413
 414 static void
 415 des3_zerokey(u_int8_t **sched)
 416 {
 417         bzero(*sched, 3*sizeof (des_key_schedule));
 418         kfree(*sched, M_CRYPTO_DATA);
 419         *sched = NULL;
 420 }
 421
 422 static void
 423 blf_encrypt(caddr_t key, u_int8_t *blk)
 424 {
 425         BF_LONG t[2];
 426
 427         memcpy(t, blk, sizeof (t));
 428         t[0] = ntohl(t[0]);
 429         t[1] = ntohl(t[1]);
 430         /* NB: BF_encrypt expects the block in host order! */
 431         BF_encrypt(t, (BF_KEY *) key);
 432         t[0] = htonl(t[0]);
 433         t[1] = htonl(t[1]);
 434         memcpy(blk, t, sizeof (t));
 435 }
 436
 437 static void
 438 blf_decrypt(caddr_t key, u_int8_t *blk)
 439 {
 440         BF_LONG t[2];
 441
 442         memcpy(t, blk, sizeof (t));
 443         t[0] = ntohl(t[0]);
 444         t[1] = ntohl(t[1]);
 445         /* NB: BF_decrypt expects the block in host order! */
 446         BF_decrypt(t, (BF_KEY *) key);
 447         t[0] = htonl(t[0]);
 448         t[1] = htonl(t[1]);
 449         memcpy(blk, t, sizeof (t));
 450 }
 451
 452 static int
 453 blf_setkey(u_int8_t **sched, u_int8_t *key, int len)
 454 {
 455         int err;
 456
 457         *sched = kmalloc(sizeof(BF_KEY), M_CRYPTO_DATA, M_INTWAIT | M_ZERO);
 458         if (*sched != NULL) {
 459                 BF_set_key((BF_KEY *) *sched, len, key);
 460                 err = 0;
 461         } else
 462                 err = ENOMEM;
 463         return err;
 464 }
 465
 466 static void
 467 blf_zerokey(u_int8_t **sched)
 468 {
 469         bzero(*sched, sizeof(BF_KEY));
 470         kfree(*sched, M_CRYPTO_DATA);
 471         *sched = NULL;
 472 }
 473
 474 static void
 475 cast5_encrypt(caddr_t key, u_int8_t *blk)
 476 {
 477         cast_encrypt((cast_key *) key, blk, blk);
 478 }
 479
 480 static void
 481 cast5_decrypt(caddr_t key, u_int8_t *blk)
 482 {
 483         cast_decrypt((cast_key *) key, blk, blk);
 484 }
 485
 486 static int
 487 cast5_setkey(u_int8_t **sched, u_int8_t *key, int len)
 488 {
 489         int err;
 490
 491         *sched = kmalloc(sizeof(cast_key), M_CRYPTO_DATA, M_INTWAIT | M_ZERO);
 492         if (*sched != NULL) {
 493                 cast_setkey((cast_key *)*sched, key, len);
 494                 err = 0;
 495         } else
 496                 err = ENOMEM;
 497         return err;
 498 }
 499
 500 static void
 501 cast5_zerokey(u_int8_t **sched)
 502 {
 503         bzero(*sched, sizeof(cast_key));
 504         kfree(*sched, M_CRYPTO_DATA);
 505         *sched = NULL;
 506 }
 507
 508 static void
 509 skipjack_encrypt(caddr_t key, u_int8_t *blk)
 510 {
 511         skipjack_forwards(blk, blk, (u_int8_t **) key);
 512 }
 513
 514 static void
 515 skipjack_decrypt(caddr_t key, u_int8_t *blk)
 516 {
 517         skipjack_backwards(blk, blk, (u_int8_t **) key);
 518 }
 519
 520 static int
 521 skipjack_setkey(u_int8_t **sched, u_int8_t *key, int len)
 522 {
 523         int err;
 524
 525         /* NB: allocate all the memory that's needed at once */
 526         *sched = kmalloc(10 * (sizeof(u_int8_t *) + 0x100),
 527                          M_CRYPTO_DATA, M_INTWAIT | M_ZERO);
 528         if (*sched != NULL) {
 529                 u_int8_t** key_tables = (u_int8_t**) *sched;
 530                 u_int8_t* table = (u_int8_t*) &key_tables[10];
 531                 int k;
 532
 533                 for (k = 0; k < 10; k++) {
 534                         key_tables[k] = table;
 535                         table += 0x100;
 536                 }
 537                 subkey_table_gen(key, (u_int8_t **) *sched);
 538                 err = 0;
 539         } else
 540                 err = ENOMEM;
 541         return err;
 542 }
 543
 544 static void
 545 skipjack_zerokey(u_int8_t **sched)
 546 {
 547         bzero(*sched, 10 * (sizeof(u_int8_t *) + 0x100));
 548         kfree(*sched, M_CRYPTO_DATA);
 549         *sched = NULL;
 550 }
 551
 552 static void
 553 rijndael128_encrypt(caddr_t key, u_int8_t *blk)
 554 {
 555         rijndael_encrypt((rijndael_ctx *) key, (u_char *) blk, (u_char *) blk);
 556 }
 557
 558 static void
 559 rijndael128_decrypt(caddr_t key, u_int8_t *blk)
 560 {
 561         rijndael_decrypt(((rijndael_ctx *) key), (u_char *) blk,
 562             (u_char *) blk);
 563 }
 564
 565 static int
 566 rijndael128_setkey(u_int8_t **sched, u_int8_t *key, int len)
 567 {
 568         int err;
 569
 570         if (len != 16 && len != 24 && len != 32)
 571                 return (EINVAL);
 572         *sched = kmalloc(sizeof(rijndael_ctx), M_CRYPTO_DATA,
 573                          M_INTWAIT | M_ZERO);
 574         if (*sched != NULL) {
 575                 rijndael_set_key((rijndael_ctx *) *sched, (u_char *) key,
 576                     len * 8);
 577                 err = 0;
 578         } else
 579                 err = ENOMEM;
 580         return err;
 581 }
 582
 583 static void
 584 rijndael128_zerokey(u_int8_t **sched)
 585 {
 586         bzero(*sched, sizeof(rijndael_ctx));
 587         kfree(*sched, M_CRYPTO_DATA);
 588         *sched = NULL;
 589 }
 590
 591 #define AES_XTS_ALPHA           0x87    /* GF(2^128) generator polynomial */
 592
 593 struct aes_xts_ctx {
 594         rijndael_ctx key1;
 595         rijndael_ctx key2;
 596         u_int8_t tweak[AES_XTS_BLOCK_LEN];
 597 };
 598
 599 void
 600 aes_xts_reinit(caddr_t key, u_int8_t *iv)
 601 {
 602         struct aes_xts_ctx *ctx = (struct aes_xts_ctx *)key;
 603         u_int64_t blocknum;
 604         u_int i;
 605
 606         /*
 607         * Prepare tweak as E_k2(IV). IV is specified as LE representation
 608         * of a 64-bit block number which we allow to be passed in directly.
 609         */
 610         bcopy(iv, &blocknum, AES_XTS_IV_LEN);
 611         for (i = 0; i < AES_XTS_IV_LEN; i++) {
 612                 ctx->tweak[i] = blocknum & 0xff;
 613                 blocknum >>= 8;
 614         }
 615         /* Last 64 bits of IV are always zero */
 616         bzero(ctx->tweak + AES_XTS_IV_LEN, AES_XTS_IV_LEN);
 617
 618         rijndael_encrypt(&ctx->key2, ctx->tweak, ctx->tweak);
 619 }
 620
 621 void
 622 aes_xts_crypt(struct aes_xts_ctx *ctx, u_int8_t *data, u_int do_encrypt)
 623 {
 624         u_int8_t block[AES_XTS_BLOCK_LEN];
 625         u_int i, carry_in, carry_out;
 626
 627         for (i = 0; i < AES_XTS_BLOCK_LEN; i++)
 628                 block[i] = data[i] ^ ctx->tweak[i];
 629
 630         if (do_encrypt)
 631                 rijndael_encrypt(&ctx->key1, block, data);
 632         else
 633                 rijndael_decrypt(&ctx->key1, block, data);
 634
 635         for (i = 0; i < AES_XTS_BLOCK_LEN; i++)
 636                 data[i] ^= ctx->tweak[i];
 637
 638         /* Exponentiate tweak */
 639         carry_in = 0;
 640         for (i = 0; i < AES_XTS_BLOCK_LEN; i++) {
 641                 carry_out = ctx->tweak[i] & 0x80;
 642                 ctx->tweak[i] = (ctx->tweak[i] << 1) | (carry_in ? 1 : 0);
 643                 carry_in = carry_out;
 644         }
 645         if (carry_in)
 646                 ctx->tweak[0] ^= AES_XTS_ALPHA;
 647         bzero(block, sizeof(block));
 648 }
 649
 650 void
 651 aes_xts_encrypt(caddr_t key, u_int8_t *data)
 652 {
 653         aes_xts_crypt((struct aes_xts_ctx *)key, data, 1);
 654 }
 655
 656 void
 657 aes_xts_decrypt(caddr_t key, u_int8_t *data)
 658 {
 659         aes_xts_crypt((struct aes_xts_ctx *)key, data, 0);
 660 }
 661
 662 int
 663 aes_xts_setkey(u_int8_t **sched, u_int8_t *key, int len)
 664 {
 665         struct aes_xts_ctx *ctx;
 666
 667         if (len != 32 && len != 64)
 668                 return -1;
 669
 670         *sched = kmalloc(sizeof(struct aes_xts_ctx), M_CRYPTO_DATA,
 671             M_WAITOK | M_ZERO);
 672         ctx = (struct aes_xts_ctx *)*sched;
 673
 674         rijndael_set_key(&ctx->key1, key, len * 4);
 675         rijndael_set_key(&ctx->key2, key + (len / 2), len * 4);
 676
 677         return 0;
 678 }
 679
 680 void
 681 aes_xts_zerokey(u_int8_t **sched)
 682 {
 683         bzero(*sched, sizeof(struct aes_xts_ctx));
 684         kfree(*sched, M_CRYPTO_DATA);
 685         *sched = NULL;
 686 }
 687
 688 #define AESCTR_NONCESIZE        4
 689
 690 struct aes_ctr_ctx {
 691         u_int32_t       ac_ek[4*(14 + 1)];
 692         u_int8_t        ac_block[AESCTR_BLOCK_LEN];
 693         int             ac_nr;
 694 };
 695
 696 void
 697 aes_ctr_reinit(caddr_t key, u_int8_t *iv)
 698 {
 699         struct aes_ctr_ctx *ctx;
 700
 701         ctx = (struct aes_ctr_ctx *)key;
 702         bcopy(iv, ctx->ac_block + AESCTR_NONCESIZE, AESCTR_IV_LEN);
 703
 704         /* reset counter */
 705         bzero(ctx->ac_block + AESCTR_NONCESIZE + AESCTR_IV_LEN, 4);
 706 }
 707
 708 void
 709 aes_ctr_crypt(caddr_t key, u_int8_t *data)
 710 {
 711         struct aes_ctr_ctx *ctx;
 712         u_int8_t keystream[AESCTR_BLOCK_LEN];
 713         int i;
 714
 715         ctx = (struct aes_ctr_ctx *)key;
 716         /* increment counter */
 717         for (i = AESCTR_BLOCK_LEN - 1;
 718         i >= AESCTR_NONCESIZE + AESCTR_IV_LEN; i--)
 719                 if (++ctx->ac_block[i])   /* continue on overflow */
 720                         break;
 721         rijndaelEncrypt(ctx->ac_ek, ctx->ac_nr, ctx->ac_block, keystream);
 722         for (i = 0; i < AESCTR_BLOCK_LEN; i++)
 723                 data[i] ^= keystream[i];
 724 }
 725
 726 int
 727 aes_ctr_setkey(u_int8_t **sched, u_int8_t *key, int len)
 728 {
 729         struct aes_ctr_ctx *ctx;
 730
 731         if (len < AESCTR_NONCESIZE)
 732                 return -1;
 733
 734         *sched = kmalloc(sizeof(struct aes_ctr_ctx), M_CRYPTO_DATA,
 735         M_WAITOK | M_ZERO);
 736         ctx = (struct aes_ctr_ctx *)*sched;
 737         ctx->ac_nr = rijndaelKeySetupEnc(ctx->ac_ek, (u_char *)key,
 738         (len - AESCTR_NONCESIZE) * 8);
 739         if (ctx->ac_nr == 0) {
 740                 aes_ctr_zerokey(sched);
 741                 return -1;
 742         }
 743         bcopy(key + len - AESCTR_NONCESIZE, ctx->ac_block, AESCTR_NONCESIZE);
 744         return 0;
 745 }
 746
 747 void
 748 aes_ctr_zerokey(u_int8_t **sched)
 749 {
 750         bzero(*sched, sizeof(struct aes_ctr_ctx));
 751         kfree(*sched, M_CRYPTO_DATA);
 752         *sched = NULL;
 753 }
 754
 755 static void
 756 cml_encrypt(caddr_t key, u_int8_t *blk)
 757 {
 758         camellia_encrypt((camellia_ctx *) key, (u_char *) blk, (u_char *) blk);
 759 }
 760
 761 static void
 762 cml_decrypt(caddr_t key, u_int8_t *blk)
 763 {
 764         camellia_decrypt(((camellia_ctx *) key), (u_char *) blk,
 765             (u_char *) blk);
 766 }
 767
 768 static int
 769 cml_setkey(u_int8_t **sched, u_int8_t *key, int len)
 770 {
 771         int err;
 772
 773         if (len != 16 && len != 24 && len != 32)
 774                 return (EINVAL);
 775         *sched = kmalloc(sizeof(camellia_ctx), M_CRYPTO_DATA,
 776                          M_INTWAIT | M_ZERO);
 777         if (*sched != NULL) {
 778                 camellia_set_key((camellia_ctx *) *sched, (u_char *) key,
 779                     len * 8);
 780                 err = 0;
 781         } else
 782                 err = ENOMEM;
 783         return err;
 784 }
 785
 786 static void
 787 cml_zerokey(u_int8_t **sched)
 788 {
 789         bzero(*sched, sizeof(camellia_ctx));
 790         kfree(*sched, M_CRYPTO_DATA);
 791         *sched = NULL;
 792 }
 793
 794 /*
 795  * And now for auth.
 796  */
 797
 798 static void
 799 null_init(void *ctx)
 800 {
 801 }
 802
 803 static int
 804 null_update(void *ctx, u_int8_t *buf, u_int16_t len)
 805 {
 806         return 0;
 807 }
 808
 809 static void
 810 null_final(u_int8_t *buf, void *ctx)
 811 {
 812         if (buf != NULL)
 813                 bzero(buf, 12);
 814 }
 815
 816 static int
 817 RMD160Update_int(void *ctx, u_int8_t *buf, u_int16_t len)
 818 {
 819         RMD160Update(ctx, buf, len);
 820         return 0;
 821 }
 822
 823 static int
 824 MD5Update_int(void *ctx, u_int8_t *buf, u_int16_t len)
 825 {
 826         MD5Update(ctx, buf, len);
 827         return 0;
 828 }
 829
 830 static void
 831 SHA1Init_int(void *ctx)
 832 {
 833         SHA1Init(ctx);
 834 }
 835
 836 static int
 837 SHA1Update_int(void *ctx, u_int8_t *buf, u_int16_t len)
 838 {
 839         SHA1Update(ctx, buf, len);
 840         return 0;
 841 }
 842
 843 static void
 844 SHA1Final_int(u_int8_t *blk, void *ctx)
 845 {
 846         SHA1Final(blk, ctx);
 847 }
 848
 849 static int
 850 SHA256Update_int(void *ctx, u_int8_t *buf, u_int16_t len)
 851 {
 852         SHA256_Update(ctx, buf, len);
 853         return 0;
 854 }
 855
 856 static int
 857 SHA384Update_int(void *ctx, u_int8_t *buf, u_int16_t len)
 858 {
 859         SHA384_Update(ctx, buf, len);
 860         return 0;
 861 }
 862
 863 static int
 864 SHA512Update_int(void *ctx, u_int8_t *buf, u_int16_t len)
 865 {
 866         SHA512_Update(ctx, buf, len);
 867         return 0;
 868 }
 869
 870 /*
 871  * And compression
 872  */
 873
 874 static u_int32_t
 875 deflate_compress(u_int8_t *data, u_int32_t size, u_int8_t **out)
 876 {
 877         return deflate_global(data, size, 0, out);
 878 }
 879
 880 static u_int32_t
 881 deflate_decompress(u_int8_t *data, u_int32_t size, u_int8_t **out)
 882 {
 883         return deflate_global(data, size, 1, out);
 884 }