sys/opencrypto/xform.c

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