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/twofish/twofish.h>
  54 #include <crypto/serpent/serpent.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 #include <opencrypto/gmac.h>
  62
  63 #include <sys/md5.h>
  64
  65 #include <opencrypto/cryptodev.h>
  66 #include <opencrypto/xform.h>
  67
  68 static void null_encrypt(caddr_t, u_int8_t *, u_int8_t *);
  69 static void null_decrypt(caddr_t, u_int8_t *, u_int8_t *);
  70 static int null_setkey(u_int8_t **, u_int8_t *, int);
  71 static void null_zerokey(u_int8_t **);
  72
  73 static  int des1_setkey(u_int8_t **, u_int8_t *, int);
  74 static  int des3_setkey(u_int8_t **, u_int8_t *, int);
  75 static  int blf_setkey(u_int8_t **, u_int8_t *, int);
  76 static  int cast5_setkey(u_int8_t **, u_int8_t *, int);
  77 static  int skipjack_setkey(u_int8_t **, u_int8_t *, int);
  78 static  int rijndael128_setkey(u_int8_t **, u_int8_t *, int);
  79 static  int aes_xts_setkey(u_int8_t **, u_int8_t *, int);
  80 static  int aes_ctr_setkey(u_int8_t **, u_int8_t *, int);
  81 static  int cml_setkey(u_int8_t **, u_int8_t *, int);
  82 static  int twofish128_setkey(u_int8_t **, u_int8_t *, int);
  83 static  int serpent128_setkey(u_int8_t **, u_int8_t *, int);
  84 static  int twofish_xts_setkey(u_int8_t **, u_int8_t *, int);
  85 static  int serpent_xts_setkey(u_int8_t **, u_int8_t *, int);
  86 static  void des1_encrypt(caddr_t, u_int8_t *, u_int8_t *);
  87 static  void des3_encrypt(caddr_t, u_int8_t *, u_int8_t *);
  88 static  void blf_encrypt(caddr_t, u_int8_t *, u_int8_t *);
  89 static  void cast5_encrypt(caddr_t, u_int8_t *, u_int8_t *);
  90 static  void skipjack_encrypt(caddr_t, u_int8_t *, u_int8_t *);
  91 static  void rijndael128_encrypt(caddr_t, u_int8_t *, u_int8_t *);
  92 static  void aes_xts_encrypt(caddr_t, u_int8_t *, u_int8_t *);
  93 static  void cml_encrypt(caddr_t, u_int8_t *, u_int8_t *);
  94 static  void twofish128_encrypt(caddr_t, u_int8_t *, u_int8_t *);
  95 static  void serpent128_encrypt(caddr_t, u_int8_t *, u_int8_t *);
  96 static  void twofish_xts_encrypt(caddr_t, u_int8_t *, u_int8_t *);
  97 static  void serpent_xts_encrypt(caddr_t, u_int8_t *, u_int8_t *);
  98 static  void des1_decrypt(caddr_t, u_int8_t *, u_int8_t *);
  99 static  void des3_decrypt(caddr_t, u_int8_t *, u_int8_t *);
 100 static  void blf_decrypt(caddr_t, u_int8_t *, u_int8_t *);
 101 static  void cast5_decrypt(caddr_t, u_int8_t *, u_int8_t *);
 102 static  void skipjack_decrypt(caddr_t, u_int8_t *, u_int8_t *);
 103 static  void rijndael128_decrypt(caddr_t, u_int8_t *, u_int8_t *);
 104 static  void aes_xts_decrypt(caddr_t, u_int8_t *, u_int8_t *);
 105 static  void cml_decrypt(caddr_t, u_int8_t *, u_int8_t *);
 106 static  void twofish128_decrypt(caddr_t, u_int8_t *, u_int8_t *);
 107 static  void serpent128_decrypt(caddr_t, u_int8_t *, u_int8_t *);
 108 static  void twofish_xts_decrypt(caddr_t, u_int8_t *, u_int8_t *);
 109 static  void serpent_xts_decrypt(caddr_t, u_int8_t *, u_int8_t *);
 110 static  void des1_zerokey(u_int8_t **);
 111 static  void des3_zerokey(u_int8_t **);
 112 static  void blf_zerokey(u_int8_t **);
 113 static  void cast5_zerokey(u_int8_t **);
 114 static  void skipjack_zerokey(u_int8_t **);
 115 static  void rijndael128_zerokey(u_int8_t **);
 116 static  void aes_xts_zerokey(u_int8_t **);
 117 static  void aes_ctr_zerokey(u_int8_t **);
 118 static  void cml_zerokey(u_int8_t **);
 119 static  void twofish128_zerokey(u_int8_t **);
 120 static  void serpent128_zerokey(u_int8_t **);
 121 static  void twofish_xts_zerokey(u_int8_t **);
 122 static  void serpent_xts_zerokey(u_int8_t **);
 123
 124 static  void aes_ctr_crypt(caddr_t, u_int8_t *, u_int8_t *);
 125
 126 static  void aes_ctr_reinit(caddr_t, u_int8_t *);
 127 static  void aes_xts_reinit(caddr_t, u_int8_t *);
 128 static  void aes_gcm_reinit(caddr_t, u_int8_t *);
 129 static  void twofish_xts_reinit(caddr_t, u_int8_t *);
 130 static  void serpent_xts_reinit(caddr_t, u_int8_t *);
 131
 132 static  void null_init(void *);
 133 static  int null_update(void *, u_int8_t *, u_int16_t);
 134 static  void null_final(u_int8_t *, void *);
 135 static  int MD5Update_int(void *, u_int8_t *, u_int16_t);
 136 static  void SHA1Init_int(void *);
 137 static  int SHA1Update_int(void *, u_int8_t *, u_int16_t);
 138 static  void SHA1Final_int(u_int8_t *, void *);
 139 static  int RMD160Update_int(void *, u_int8_t *, u_int16_t);
 140 static  int SHA256Update_int(void *, u_int8_t *, u_int16_t);
 141 static  int SHA384Update_int(void *, u_int8_t *, u_int16_t);
 142 static  int SHA512Update_int(void *, u_int8_t *, u_int16_t);
 143
 144 static  u_int32_t deflate_compress(u_int8_t *, u_int32_t, u_int8_t **);
 145 static  u_int32_t deflate_decompress(u_int8_t *, u_int32_t, u_int8_t **);
 146
 147 /* Helper */
 148 struct aes_xts_ctx;
 149 struct twofish_xts_ctx;
 150 struct serpent_xts_ctx;
 151 static void aes_xts_crypt(struct aes_xts_ctx *, u_int8_t *, u_int8_t *, u_int);
 152 static void twofish_xts_crypt(struct twofish_xts_ctx *, u_int8_t *, u_int8_t *,
 153     u_int);
 154 static void serpent_xts_crypt(struct serpent_xts_ctx *, u_int8_t *, u_int8_t *,
 155     u_int);
 156
 157 MALLOC_DEFINE(M_XDATA, "xform", "xform data buffers");
 158
 159 /* Encryption instances */
 160 struct enc_xform enc_xform_null = {
 161         CRYPTO_NULL_CBC, "NULL",
 162         /* NB: blocksize of 4 is to generate a properly aligned ESP header */
 163         NULL_BLOCK_LEN, NULL_BLOCK_LEN, 0, 256, /* 2048 bits, max key */
 164         null_encrypt,
 165         null_decrypt,
 166         null_setkey,
 167         null_zerokey,
 168         NULL
 169 };
 170
 171 struct enc_xform enc_xform_des = {
 172         CRYPTO_DES_CBC, "DES",
 173         DES_BLOCK_LEN, DES_BLOCK_LEN, 8, 8,
 174         des1_encrypt,
 175         des1_decrypt,
 176         des1_setkey,
 177         des1_zerokey,
 178         NULL
 179 };
 180
 181 struct enc_xform enc_xform_3des = {
 182         CRYPTO_3DES_CBC, "3DES",
 183         DES3_BLOCK_LEN, DES3_BLOCK_LEN, 24, 24,
 184         des3_encrypt,
 185         des3_decrypt,
 186         des3_setkey,
 187         des3_zerokey,
 188         NULL
 189 };
 190
 191 struct enc_xform enc_xform_blf = {
 192         CRYPTO_BLF_CBC, "Blowfish",
 193         BLOWFISH_BLOCK_LEN, BLOWFISH_BLOCK_LEN, 5, 56 /* 448 bits, max key */,
 194         blf_encrypt,
 195         blf_decrypt,
 196         blf_setkey,
 197         blf_zerokey,
 198         NULL
 199 };
 200
 201 struct enc_xform enc_xform_cast5 = {
 202         CRYPTO_CAST_CBC, "CAST-128",
 203         CAST128_BLOCK_LEN, CAST128_BLOCK_LEN, 5, 16,
 204         cast5_encrypt,
 205         cast5_decrypt,
 206         cast5_setkey,
 207         cast5_zerokey,
 208         NULL
 209 };
 210
 211 struct enc_xform enc_xform_skipjack = {
 212         CRYPTO_SKIPJACK_CBC, "Skipjack",
 213         SKIPJACK_BLOCK_LEN, SKIPJACK_BLOCK_LEN, 10, 10,
 214         skipjack_encrypt,
 215         skipjack_decrypt,
 216         skipjack_setkey,
 217         skipjack_zerokey,
 218         NULL
 219 };
 220
 221 struct enc_xform enc_xform_rijndael128 = {
 222         CRYPTO_RIJNDAEL128_CBC, "Rijndael-128/AES",
 223         RIJNDAEL128_BLOCK_LEN, RIJNDAEL128_BLOCK_LEN, 8, 32,
 224         rijndael128_encrypt,
 225         rijndael128_decrypt,
 226         rijndael128_setkey,
 227         rijndael128_zerokey,
 228         NULL
 229 };
 230
 231 struct enc_xform enc_xform_aes_xts = {
 232         CRYPTO_AES_XTS, "AES-XTS",
 233         AES_XTS_BLOCK_LEN, AES_XTS_IV_LEN, 32, 64,
 234         aes_xts_encrypt,
 235         aes_xts_decrypt,
 236         aes_xts_setkey,
 237         aes_xts_zerokey,
 238         aes_xts_reinit
 239 };
 240
 241 struct enc_xform enc_xform_aes_ctr = {
 242         CRYPTO_AES_CTR, "AES-CTR",
 243         AESCTR_BLOCK_LEN, AESCTR_IV_LEN, 16+4, 32+4,
 244         aes_ctr_crypt,
 245         aes_ctr_crypt,
 246         aes_ctr_setkey,
 247         aes_ctr_zerokey,
 248         aes_ctr_reinit
 249 };
 250
 251 struct enc_xform enc_xform_aes_gcm = {
 252         CRYPTO_AES_GCM_16, "AES-GCM",
 253         AESGCM_BLOCK_LEN, AESGCM_IV_LEN, 16+4, 32+4,
 254         aes_ctr_crypt,
 255         aes_ctr_crypt,
 256         aes_ctr_setkey,
 257         aes_ctr_zerokey,
 258         aes_gcm_reinit
 259 };
 260
 261 struct enc_xform enc_xform_aes_gmac = {
 262         CRYPTO_AES_GMAC, "AES-GMAC",
 263         AESGMAC_BLOCK_LEN, AESGMAC_IV_LEN, 16+4, 32+4,
 264         NULL,
 265         NULL,
 266         NULL,
 267         NULL,
 268         NULL
 269 };
 270
 271 struct enc_xform enc_xform_arc4 = {
 272         CRYPTO_ARC4, "ARC4",
 273         1, 1, 1, 32,
 274         NULL,
 275         NULL,
 276         NULL,
 277         NULL,
 278         NULL
 279 };
 280
 281 struct enc_xform enc_xform_camellia = {
 282         CRYPTO_CAMELLIA_CBC, "Camellia",
 283         CAMELLIA_BLOCK_LEN, CAMELLIA_BLOCK_LEN, 8, 32,
 284         cml_encrypt,
 285         cml_decrypt,
 286         cml_setkey,
 287         cml_zerokey,
 288         NULL
 289 };
 290
 291 struct enc_xform enc_xform_twofish = {
 292         CRYPTO_TWOFISH_CBC, "Twofish",
 293         TWOFISH_BLOCK_LEN, TWOFISH_BLOCK_LEN, 8, 32,
 294         twofish128_encrypt,
 295         twofish128_decrypt,
 296         twofish128_setkey,
 297         twofish128_zerokey,
 298         NULL
 299 };
 300
 301 struct enc_xform enc_xform_serpent = {
 302         CRYPTO_SERPENT_CBC, "Serpent",
 303         SERPENT_BLOCK_LEN, SERPENT_BLOCK_LEN, 8, 32,
 304         serpent128_encrypt,
 305         serpent128_decrypt,
 306         serpent128_setkey,
 307         serpent128_zerokey,
 308         NULL
 309 };
 310
 311 struct enc_xform enc_xform_twofish_xts = {
 312         CRYPTO_TWOFISH_XTS, "TWOFISH-XTS",
 313         TWOFISH_XTS_BLOCK_LEN, TWOFISH_XTS_IV_LEN, 32, 64,
 314         twofish_xts_encrypt,
 315         twofish_xts_decrypt,
 316         twofish_xts_setkey,
 317         twofish_xts_zerokey,
 318         twofish_xts_reinit
 319 };
 320
 321 struct enc_xform enc_xform_serpent_xts = {
 322         CRYPTO_SERPENT_XTS, "SERPENT-XTS",
 323         SERPENT_XTS_BLOCK_LEN, SERPENT_XTS_IV_LEN, 32, 64,
 324         serpent_xts_encrypt,
 325         serpent_xts_decrypt,
 326         serpent_xts_setkey,
 327         serpent_xts_zerokey,
 328         serpent_xts_reinit
 329 };
 330
 331
 332 /* Authentication instances */
 333 struct auth_hash auth_hash_null = {
 334         CRYPTO_NULL_HMAC, "NULL-HMAC",
 335         0, NULL_HASH_LEN, NULL_HMAC_BLOCK_LEN, sizeof(int),     /* NB: context isn't used */
 336         null_init, NULL, NULL, null_update, null_final
 337 };
 338
 339 struct auth_hash auth_hash_hmac_md5 = {
 340         CRYPTO_MD5_HMAC, "HMAC-MD5",
 341         16, MD5_HASH_LEN, MD5_HMAC_BLOCK_LEN, sizeof(MD5_CTX),
 342         (void (*) (void *)) MD5Init, NULL, NULL,
 343         MD5Update_int,
 344         (void (*) (u_int8_t *, void *)) MD5Final
 345 };
 346
 347 struct auth_hash auth_hash_hmac_sha1 = {
 348         CRYPTO_SHA1_HMAC, "HMAC-SHA1",
 349         20, SHA1_HASH_LEN, SHA1_HMAC_BLOCK_LEN, sizeof(SHA1_CTX),
 350         SHA1Init_int, NULL, NULL,
 351         SHA1Update_int, SHA1Final_int
 352 };
 353
 354 struct auth_hash auth_hash_hmac_ripemd_160 = {
 355         CRYPTO_RIPEMD160_HMAC, "HMAC-RIPEMD-160",
 356         20, RIPEMD160_HASH_LEN, RIPEMD160_HMAC_BLOCK_LEN, sizeof(RMD160_CTX),
 357         (void (*)(void *)) RMD160Init, NULL, NULL,
 358         RMD160Update_int,
 359         (void (*)(u_int8_t *, void *)) RMD160Final
 360 };
 361
 362 struct auth_hash auth_hash_key_md5 = {
 363         CRYPTO_MD5_KPDK, "Keyed MD5",
 364         0, MD5_KPDK_HASH_LEN, 0, sizeof(MD5_CTX),
 365         (void (*)(void *)) MD5Init, NULL, NULL,
 366         MD5Update_int,
 367         (void (*)(u_int8_t *, void *)) MD5Final
 368 };
 369
 370 struct auth_hash auth_hash_key_sha1 = {
 371         CRYPTO_SHA1_KPDK, "Keyed SHA1",
 372         0, SHA1_KPDK_HASH_LEN, 0, sizeof(SHA1_CTX),
 373         SHA1Init_int, NULL, NULL,
 374         SHA1Update_int, SHA1Final_int
 375 };
 376
 377 struct auth_hash auth_hash_hmac_sha2_256 = {
 378         CRYPTO_SHA2_256_HMAC, "HMAC-SHA2-256",
 379         32, SHA2_256_HASH_LEN, SHA2_256_HMAC_BLOCK_LEN, sizeof(SHA256_CTX),
 380         (void (*)(void *)) SHA256_Init, NULL, NULL,
 381         SHA256Update_int,
 382         (void (*)(u_int8_t *, void *)) SHA256_Final
 383 };
 384
 385 struct auth_hash auth_hash_hmac_sha2_384 = {
 386         CRYPTO_SHA2_384_HMAC, "HMAC-SHA2-384",
 387         48, SHA2_384_HASH_LEN, SHA2_384_HMAC_BLOCK_LEN, sizeof(SHA384_CTX),
 388         (void (*)(void *)) SHA384_Init, NULL, NULL,
 389         SHA384Update_int,
 390         (void (*)(u_int8_t *, void *)) SHA384_Final
 391 };
 392
 393 struct auth_hash auth_hash_hmac_sha2_512 = {
 394         CRYPTO_SHA2_512_HMAC, "HMAC-SHA2-512",
 395         64, SHA2_512_HASH_LEN, SHA2_512_HMAC_BLOCK_LEN, sizeof(SHA512_CTX),
 396         (void (*)(void *)) SHA512_Init, NULL, NULL,
 397         SHA512Update_int,
 398         (void (*)(u_int8_t *, void *)) SHA512_Final
 399 };
 400
 401 struct auth_hash auth_hash_gmac_aes_128 = {
 402         CRYPTO_AES_128_GMAC, "GMAC-AES-128",
 403         16+4, 16, 16, sizeof(AES_GMAC_CTX),
 404         (void (*)(void *)) AES_GMAC_Init,
 405         (void (*)(void *, const u_int8_t *, u_int16_t)) AES_GMAC_Setkey,
 406         (void (*)(void *, const u_int8_t *, u_int16_t)) AES_GMAC_Reinit,
 407         (int  (*)(void *, u_int8_t *, u_int16_t)) AES_GMAC_Update,
 408         (void (*)(u_int8_t *, void *)) AES_GMAC_Final
 409 };
 410
 411 struct auth_hash auth_hash_gmac_aes_192 = {
 412         CRYPTO_AES_192_GMAC, "GMAC-AES-192",
 413         24+4, 16, 16, sizeof(AES_GMAC_CTX),
 414         (void (*)(void *)) AES_GMAC_Init,
 415         (void (*)(void *, const u_int8_t *, u_int16_t)) AES_GMAC_Setkey,
 416         (void (*)(void *, const u_int8_t *, u_int16_t)) AES_GMAC_Reinit,
 417         (int  (*)(void *, u_int8_t *, u_int16_t)) AES_GMAC_Update,
 418         (void (*)(u_int8_t *, void *)) AES_GMAC_Final
 419 };
 420
 421 struct auth_hash auth_hash_gmac_aes_256 = {
 422         CRYPTO_AES_256_GMAC, "GMAC-AES-256",
 423         32+4, 16, 16, sizeof(AES_GMAC_CTX),
 424         (void (*)(void *)) AES_GMAC_Init,
 425         (void (*)(void *, const u_int8_t *, u_int16_t)) AES_GMAC_Setkey,
 426         (void (*)(void *, const u_int8_t *, u_int16_t)) AES_GMAC_Reinit,
 427         (int  (*)(void *, u_int8_t *, u_int16_t)) AES_GMAC_Update,
 428         (void (*)(u_int8_t *, void *)) AES_GMAC_Final
 429 };
 430
 431 /* Compression instance */
 432 struct comp_algo comp_algo_deflate = {
 433         CRYPTO_DEFLATE_COMP, "Deflate",
 434         90, deflate_compress,
 435         deflate_decompress
 436 };
 437
 438 /*
 439  * Encryption wrapper routines.
 440  */
 441 static void
 442 null_encrypt(caddr_t key, u_int8_t *blk, u_int8_t *iv)
 443 {
 444 }
 445 static void
 446 null_decrypt(caddr_t key, u_int8_t *blk, u_int8_t *iv)
 447 {
 448 }
 449 static int
 450 null_setkey(u_int8_t **sched, u_int8_t *key, int len)
 451 {
 452         *sched = NULL;
 453         return 0;
 454 }
 455 static void
 456 null_zerokey(u_int8_t **sched)
 457 {
 458         *sched = NULL;
 459 }
 460
 461 static void
 462 des1_encrypt(caddr_t key, u_int8_t *blk, u_int8_t *iv)
 463 {
 464         des_cblock *cb = (des_cblock *) blk;
 465         des_key_schedule *p = (des_key_schedule *) key;
 466
 467         des_ecb_encrypt(cb, cb, p[0], DES_ENCRYPT);
 468 }
 469
 470 static void
 471 des1_decrypt(caddr_t key, u_int8_t *blk, u_int8_t *iv)
 472 {
 473         des_cblock *cb = (des_cblock *) blk;
 474         des_key_schedule *p = (des_key_schedule *) key;
 475
 476         des_ecb_encrypt(cb, cb, p[0], DES_DECRYPT);
 477 }
 478
 479 static int
 480 des1_setkey(u_int8_t **sched, u_int8_t *key, int len)
 481 {
 482         des_key_schedule *p;
 483         int err;
 484
 485         p = kmalloc(sizeof (des_key_schedule),
 486                     M_CRYPTO_DATA, M_INTWAIT | M_ZERO);
 487         if (p != NULL) {
 488                 des_set_key((des_cblock *) key, p[0]);
 489                 err = 0;
 490         } else
 491                 err = ENOMEM;
 492         *sched = (u_int8_t *) p;
 493         return err;
 494 }
 495
 496 static void
 497 des1_zerokey(u_int8_t **sched)
 498 {
 499         bzero(*sched, sizeof (des_key_schedule));
 500         kfree(*sched, M_CRYPTO_DATA);
 501         *sched = NULL;
 502 }
 503
 504 static void
 505 des3_encrypt(caddr_t key, u_int8_t *blk, u_int8_t *iv)
 506 {
 507         des_cblock *cb = (des_cblock *) blk;
 508         des_key_schedule *p = (des_key_schedule *) key;
 509
 510         des_ecb3_encrypt(cb, cb, p[0], p[1], p[2], DES_ENCRYPT);
 511 }
 512
 513 static void
 514 des3_decrypt(caddr_t key, u_int8_t *blk, u_int8_t *iv)
 515 {
 516         des_cblock *cb = (des_cblock *) blk;
 517         des_key_schedule *p = (des_key_schedule *) key;
 518
 519         des_ecb3_encrypt(cb, cb, p[0], p[1], p[2], DES_DECRYPT);
 520 }
 521
 522 static int
 523 des3_setkey(u_int8_t **sched, u_int8_t *key, int len)
 524 {
 525         des_key_schedule *p;
 526         int err;
 527
 528         p = kmalloc(3 * sizeof(des_key_schedule),
 529                     M_CRYPTO_DATA, M_INTWAIT | M_ZERO);
 530         if (p != NULL) {
 531                 des_set_key((des_cblock *)(key +  0), p[0]);
 532                 des_set_key((des_cblock *)(key +  8), p[1]);
 533                 des_set_key((des_cblock *)(key + 16), p[2]);
 534                 err = 0;
 535         } else
 536                 err = ENOMEM;
 537         *sched = (u_int8_t *) p;
 538         return err;
 539 }
 540
 541 static void
 542 des3_zerokey(u_int8_t **sched)
 543 {
 544         bzero(*sched, 3*sizeof (des_key_schedule));
 545         kfree(*sched, M_CRYPTO_DATA);
 546         *sched = NULL;
 547 }
 548
 549 static void
 550 blf_encrypt(caddr_t key, u_int8_t *blk, u_int8_t *iv)
 551 {
 552         BF_LONG t[2];
 553
 554         memcpy(t, blk, sizeof (t));
 555         t[0] = ntohl(t[0]);
 556         t[1] = ntohl(t[1]);
 557         /* NB: BF_encrypt expects the block in host order! */
 558         BF_encrypt(t, (BF_KEY *) key);
 559         t[0] = htonl(t[0]);
 560         t[1] = htonl(t[1]);
 561         memcpy(blk, t, sizeof (t));
 562 }
 563
 564 static void
 565 blf_decrypt(caddr_t key, u_int8_t *blk, u_int8_t *iv)
 566 {
 567         BF_LONG t[2];
 568
 569         memcpy(t, blk, sizeof (t));
 570         t[0] = ntohl(t[0]);
 571         t[1] = ntohl(t[1]);
 572         /* NB: BF_decrypt expects the block in host order! */
 573         BF_decrypt(t, (BF_KEY *) key);
 574         t[0] = htonl(t[0]);
 575         t[1] = htonl(t[1]);
 576         memcpy(blk, t, sizeof (t));
 577 }
 578
 579 static int
 580 blf_setkey(u_int8_t **sched, u_int8_t *key, int len)
 581 {
 582         int err;
 583
 584         *sched = kmalloc(sizeof(BF_KEY), M_CRYPTO_DATA, M_INTWAIT | M_ZERO);
 585         if (*sched != NULL) {
 586                 BF_set_key((BF_KEY *) *sched, len, key);
 587                 err = 0;
 588         } else
 589                 err = ENOMEM;
 590         return err;
 591 }
 592
 593 static void
 594 blf_zerokey(u_int8_t **sched)
 595 {
 596         bzero(*sched, sizeof(BF_KEY));
 597         kfree(*sched, M_CRYPTO_DATA);
 598         *sched = NULL;
 599 }
 600
 601 static void
 602 cast5_encrypt(caddr_t key, u_int8_t *blk, u_int8_t *iv)
 603 {
 604         cast_encrypt((cast_key *) key, blk, blk);
 605 }
 606
 607 static void
 608 cast5_decrypt(caddr_t key, u_int8_t *blk, u_int8_t *iv)
 609 {
 610         cast_decrypt((cast_key *) key, blk, blk);
 611 }
 612
 613 static int
 614 cast5_setkey(u_int8_t **sched, u_int8_t *key, int len)
 615 {
 616         int err;
 617
 618         *sched = kmalloc(sizeof(cast_key), M_CRYPTO_DATA, M_INTWAIT | M_ZERO);
 619         if (*sched != NULL) {
 620                 cast_setkey((cast_key *)*sched, key, len);
 621                 err = 0;
 622         } else
 623                 err = ENOMEM;
 624         return err;
 625 }
 626
 627 static void
 628 cast5_zerokey(u_int8_t **sched)
 629 {
 630         bzero(*sched, sizeof(cast_key));
 631         kfree(*sched, M_CRYPTO_DATA);
 632         *sched = NULL;
 633 }
 634
 635 static void
 636 skipjack_encrypt(caddr_t key, u_int8_t *blk, u_int8_t *iv)
 637 {
 638         skipjack_forwards(blk, blk, (u_int8_t **) key);
 639 }
 640
 641 static void
 642 skipjack_decrypt(caddr_t key, u_int8_t *blk, u_int8_t *iv)
 643 {
 644         skipjack_backwards(blk, blk, (u_int8_t **) key);
 645 }
 646
 647 static int
 648 skipjack_setkey(u_int8_t **sched, u_int8_t *key, int len)
 649 {
 650         int err;
 651
 652         /* NB: allocate all the memory that's needed at once */
 653         *sched = kmalloc(10 * (sizeof(u_int8_t *) + 0x100),
 654                          M_CRYPTO_DATA, M_INTWAIT | M_ZERO);
 655         if (*sched != NULL) {
 656                 u_int8_t** key_tables = (u_int8_t**) *sched;
 657                 u_int8_t* table = (u_int8_t*) &key_tables[10];
 658                 int k;
 659
 660                 for (k = 0; k < 10; k++) {
 661                         key_tables[k] = table;
 662                         table += 0x100;
 663                 }
 664                 subkey_table_gen(key, (u_int8_t **) *sched);
 665                 err = 0;
 666         } else
 667                 err = ENOMEM;
 668         return err;
 669 }
 670
 671 static void
 672 skipjack_zerokey(u_int8_t **sched)
 673 {
 674         bzero(*sched, 10 * (sizeof(u_int8_t *) + 0x100));
 675         kfree(*sched, M_CRYPTO_DATA);
 676         *sched = NULL;
 677 }
 678
 679 static void
 680 rijndael128_encrypt(caddr_t key, u_int8_t *blk, u_int8_t *iv)
 681 {
 682         rijndael_encrypt((rijndael_ctx *) key, (u_char *) blk, (u_char *) blk);
 683 }
 684
 685 static void
 686 rijndael128_decrypt(caddr_t key, u_int8_t *blk, u_int8_t *iv)
 687 {
 688         rijndael_decrypt(((rijndael_ctx *) key), (u_char *) blk,
 689             (u_char *) blk);
 690 }
 691
 692 static int
 693 rijndael128_setkey(u_int8_t **sched, u_int8_t *key, int len)
 694 {
 695         int err;
 696
 697         if (len != 16 && len != 24 && len != 32)
 698                 return (EINVAL);
 699         *sched = kmalloc(sizeof(rijndael_ctx), M_CRYPTO_DATA,
 700                          M_INTWAIT | M_ZERO);
 701         if (*sched != NULL) {
 702                 rijndael_set_key((rijndael_ctx *) *sched, (u_char *) key,
 703                     len * 8);
 704                 err = 0;
 705         } else
 706                 err = ENOMEM;
 707         return err;
 708 }
 709
 710 static void
 711 rijndael128_zerokey(u_int8_t **sched)
 712 {
 713         bzero(*sched, sizeof(rijndael_ctx));
 714         kfree(*sched, M_CRYPTO_DATA);
 715         *sched = NULL;
 716 }
 717
 718 #define AES_XTS_ALPHA           0x87    /* GF(2^128) generator polynomial */
 719
 720 struct aes_xts_ctx {
 721         rijndael_ctx key1;
 722         rijndael_ctx key2;
 723 };
 724
 725 void
 726 aes_xts_reinit(caddr_t key, u_int8_t *iv)
 727 {
 728         struct aes_xts_ctx *ctx = (struct aes_xts_ctx *)key;
 729 #if 0
 730         u_int64_t blocknum;
 731         u_int i;
 732 #endif
 733
 734 #if 0
 735         /*
 736          * Prepare tweak as E_k2(IV). IV is specified as LE representation
 737          * of a 64-bit block number which we allow to be passed in directly.
 738          */
 739         /* XXX: possibly use htole64? */
 740 #endif
 741         /* Last 64 bits of IV are always zero */
 742         bzero(iv + AES_XTS_IV_LEN, AES_XTS_IV_LEN);
 743
 744         rijndael_encrypt(&ctx->key2, iv, iv);
 745 }
 746
 747 void
 748 aes_xts_crypt(struct aes_xts_ctx *ctx, u_int8_t *data, u_int8_t *iv, u_int do_encrypt)
 749 {
 750         u_int8_t block[AES_XTS_BLOCK_LEN];
 751         u_int i, carry_in, carry_out;
 752
 753         for (i = 0; i < AES_XTS_BLOCK_LEN; i++)
 754                 block[i] = data[i] ^ iv[i];
 755
 756         if (do_encrypt)
 757                 rijndael_encrypt(&ctx->key1, block, data);
 758         else
 759                 rijndael_decrypt(&ctx->key1, block, data);
 760
 761         for (i = 0; i < AES_XTS_BLOCK_LEN; i++)
 762                 data[i] ^= iv[i];
 763
 764         /* Exponentiate tweak */
 765         carry_in = 0;
 766         for (i = 0; i < AES_XTS_BLOCK_LEN; i++) {
 767                 carry_out = iv[i] & 0x80;
 768                 iv[i] = (iv[i] << 1) | (carry_in ? 1 : 0);
 769                 carry_in = carry_out;
 770         }
 771         if (carry_in)
 772                 iv[0] ^= AES_XTS_ALPHA;
 773         bzero(block, sizeof(block));
 774 }
 775
 776 void
 777 aes_xts_encrypt(caddr_t key, u_int8_t *data, u_int8_t *iv)
 778 {
 779         aes_xts_crypt((struct aes_xts_ctx *)key, data, iv, 1);
 780 }
 781
 782 void
 783 aes_xts_decrypt(caddr_t key, u_int8_t *data, u_int8_t *iv)
 784 {
 785         aes_xts_crypt((struct aes_xts_ctx *)key, data, iv, 0);
 786 }
 787
 788 int
 789 aes_xts_setkey(u_int8_t **sched, u_int8_t *key, int len)
 790 {
 791         struct aes_xts_ctx *ctx;
 792
 793         if (len != 32 && len != 64)
 794                 return -1;
 795
 796         *sched = kmalloc(sizeof(struct aes_xts_ctx), M_CRYPTO_DATA,
 797             M_WAITOK | M_ZERO);
 798         ctx = (struct aes_xts_ctx *)*sched;
 799
 800         rijndael_set_key(&ctx->key1, key, len * 4);
 801         rijndael_set_key(&ctx->key2, key + (len / 2), len * 4);
 802
 803         return 0;
 804 }
 805
 806 void
 807 aes_xts_zerokey(u_int8_t **sched)
 808 {
 809         bzero(*sched, sizeof(struct aes_xts_ctx));
 810         kfree(*sched, M_CRYPTO_DATA);
 811         *sched = NULL;
 812 }
 813
 814 #define AESCTR_NONCESIZE        4
 815
 816 struct aes_ctr_ctx {
 817         u_int32_t       ac_ek[4*(14 + 1)];
 818         u_int8_t        ac_block[AESCTR_BLOCK_LEN];
 819         int             ac_nr;
 820 };
 821
 822 void
 823 aes_ctr_reinit(caddr_t key, u_int8_t *iv)
 824 {
 825         struct aes_ctr_ctx *ctx;
 826
 827         ctx = (struct aes_ctr_ctx *)key;
 828         bcopy(iv, iv + AESCTR_NONCESIZE, AESCTR_IV_LEN);
 829         bcopy(ctx->ac_block, iv, AESCTR_NONCESIZE);
 830
 831         /* reset counter */
 832         bzero(iv + AESCTR_NONCESIZE + AESCTR_IV_LEN, 4);
 833 }
 834
 835 void
 836 aes_ctr_crypt(caddr_t key, u_int8_t *data, u_int8_t *iv)
 837 {
 838         struct aes_ctr_ctx *ctx;
 839         u_int8_t keystream[AESCTR_BLOCK_LEN];
 840         int i;
 841
 842         ctx = (struct aes_ctr_ctx *)key;
 843         /* increment counter */
 844         for (i = AESCTR_BLOCK_LEN - 1;
 845         i >= AESCTR_NONCESIZE + AESCTR_IV_LEN; i--)
 846                 if (++iv[i])   /* continue on overflow */
 847                         break;
 848         rijndaelEncrypt(ctx->ac_ek, ctx->ac_nr, iv, keystream);
 849         for (i = 0; i < AESCTR_BLOCK_LEN; i++)
 850                 data[i] ^= keystream[i];
 851         bzero(keystream, sizeof(keystream));
 852 }
 853
 854 int
 855 aes_ctr_setkey(u_int8_t **sched, u_int8_t *key, int len)
 856 {
 857         struct aes_ctr_ctx *ctx;
 858
 859         if (len < AESCTR_NONCESIZE)
 860                 return -1;
 861
 862         *sched = kmalloc(sizeof(struct aes_ctr_ctx), M_CRYPTO_DATA,
 863         M_WAITOK | M_ZERO);
 864         ctx = (struct aes_ctr_ctx *)*sched;
 865         ctx->ac_nr = rijndaelKeySetupEnc(ctx->ac_ek, (u_char *)key,
 866         (len - AESCTR_NONCESIZE) * 8);
 867         if (ctx->ac_nr == 0) {
 868                 aes_ctr_zerokey(sched);
 869                 return -1;
 870         }
 871         bcopy(key + len - AESCTR_NONCESIZE, ctx->ac_block, AESCTR_NONCESIZE);
 872         return 0;
 873 }
 874
 875 void
 876 aes_ctr_zerokey(u_int8_t **sched)
 877 {
 878         bzero(*sched, sizeof(struct aes_ctr_ctx));
 879         kfree(*sched, M_CRYPTO_DATA);
 880         *sched = NULL;
 881 }
 882
 883 static void
 884 aes_gcm_reinit(caddr_t key, u_int8_t *iv)
 885 {
 886         struct aes_ctr_ctx *ctx;
 887
 888         ctx = (struct aes_ctr_ctx *)key;
 889         bcopy(iv, ctx->ac_block + AESCTR_NONCESIZE, AESCTR_IV_LEN);
 890
 891         /* reset counter */
 892         bzero(ctx->ac_block + AESCTR_NONCESIZE + AESCTR_IV_LEN, 4);
 893         ctx->ac_block[AESCTR_BLOCK_LEN - 1] = 1; /* GCM starts with 1 */
 894 }
 895
 896 static void
 897 cml_encrypt(caddr_t key, u_int8_t *blk, u_int8_t *iv)
 898 {
 899         camellia_encrypt((camellia_ctx *) key, (u_char *) blk, (u_char *) blk);
 900 }
 901
 902 static void
 903 cml_decrypt(caddr_t key, u_int8_t *blk, u_int8_t *iv)
 904 {
 905         camellia_decrypt(((camellia_ctx *) key), (u_char *) blk,
 906             (u_char *) blk);
 907 }
 908
 909 static int
 910 cml_setkey(u_int8_t **sched, u_int8_t *key, int len)
 911 {
 912         int err;
 913
 914         if (len != 16 && len != 24 && len != 32)
 915                 return (EINVAL);
 916         *sched = kmalloc(sizeof(camellia_ctx), M_CRYPTO_DATA,
 917                          M_INTWAIT | M_ZERO);
 918         if (*sched != NULL) {
 919                 camellia_set_key((camellia_ctx *) *sched, (u_char *) key,
 920                     len * 8);
 921                 err = 0;
 922         } else
 923                 err = ENOMEM;
 924         return err;
 925 }
 926
 927 static void
 928 cml_zerokey(u_int8_t **sched)
 929 {
 930         bzero(*sched, sizeof(camellia_ctx));
 931         kfree(*sched, M_CRYPTO_DATA);
 932         *sched = NULL;
 933 }
 934
 935 static void
 936 twofish128_encrypt(caddr_t key, u_int8_t *blk, u_int8_t *iv)
 937 {
 938         twofish_encrypt((twofish_ctx *) key, (u_int8_t *) blk,
 939             (u_int8_t *) blk);
 940 }
 941
 942 static void
 943 twofish128_decrypt(caddr_t key, u_int8_t *blk, u_int8_t *iv)
 944 {
 945         twofish_decrypt(((twofish_ctx *) key), (u_int8_t *) blk,
 946             (u_int8_t *) blk);
 947 }
 948
 949 static int
 950 twofish128_setkey(u_int8_t **sched, u_int8_t *key, int len)
 951 {
 952         int err;
 953
 954         if (len != 16 && len != 24 && len != 32)
 955                 return (EINVAL);
 956         *sched = kmalloc(sizeof(twofish_ctx), M_CRYPTO_DATA,
 957                          M_INTWAIT | M_ZERO);
 958         if (*sched != NULL) {
 959                 twofish_set_key((twofish_ctx *) *sched, (u_int8_t *) key,
 960                     len * 8);
 961                 err = 0;
 962         } else
 963                 err = ENOMEM;
 964         return err;
 965 }
 966
 967 static void
 968 twofish128_zerokey(u_int8_t **sched)
 969 {
 970         bzero(*sched, sizeof(twofish_ctx));
 971         kfree(*sched, M_CRYPTO_DATA);
 972         *sched = NULL;
 973 }
 974
 975 static void
 976 serpent128_encrypt(caddr_t key, u_int8_t *blk, u_int8_t *iv)
 977 {
 978         serpent_encrypt((serpent_ctx *) key, (u_int8_t *) blk,
 979             (u_int8_t *) blk);
 980 }
 981
 982 static void
 983 serpent128_decrypt(caddr_t key, u_int8_t *blk, u_int8_t *iv)
 984 {
 985         serpent_decrypt(((serpent_ctx *) key), (u_int8_t *) blk,
 986             (u_int8_t *) blk);
 987 }
 988
 989 static int
 990 serpent128_setkey(u_int8_t **sched, u_int8_t *key, int len)
 991 {
 992         int err;
 993
 994         if (len != 16 && len != 24 && len != 32)
 995                 return (EINVAL);
 996         *sched = kmalloc(sizeof(serpent_ctx), M_CRYPTO_DATA,
 997                          M_INTWAIT | M_ZERO);
 998         if (*sched != NULL) {
 999                 serpent_set_key((serpent_ctx *) *sched, (u_int8_t *) key,
1000                     len * 8);
1001                 err = 0;
1002         } else
1003                 err = ENOMEM;
1004         return err;
1005 }
1006
1007 static void
1008 serpent128_zerokey(u_int8_t **sched)
1009 {
1010         bzero(*sched, sizeof(serpent_ctx));
1011         kfree(*sched, M_CRYPTO_DATA);
1012         *sched = NULL;
1013 }
1014
1015
1016 struct twofish_xts_ctx {
1017         twofish_ctx key1;
1018         twofish_ctx key2;
1019 };
1020
1021 void
1022 twofish_xts_reinit(caddr_t key, u_int8_t *iv)
1023 {
1024         struct twofish_xts_ctx *ctx = (struct twofish_xts_ctx *)key;
1025 #if 0
1026         u_int64_t blocknum;
1027 #endif
1028
1029 #if 0
1030         /*
1031          * Prepare tweak as E_k2(IV). IV is specified as LE representation
1032          * of a 64-bit block number which we allow to be passed in directly.
1033          */
1034         /* XXX: possibly use htole64? */
1035 #endif
1036         /* Last 64 bits of IV are always zero */
1037         bzero(iv + TWOFISH_XTS_IV_LEN, TWOFISH_XTS_IV_LEN);
1038
1039         twofish_encrypt(&ctx->key2, iv, iv);
1040 }
1041
1042 void
1043 twofish_xts_crypt(struct twofish_xts_ctx *ctx, u_int8_t *data, u_int8_t *iv,
1044     u_int do_encrypt)
1045 {
1046         u_int8_t block[TWOFISH_XTS_BLOCK_LEN];
1047         u_int i, carry_in, carry_out;
1048
1049         for (i = 0; i < TWOFISH_XTS_BLOCK_LEN; i++)
1050                 block[i] = data[i] ^ iv[i];
1051
1052         if (do_encrypt)
1053                 twofish_encrypt(&ctx->key1, block, data);
1054         else
1055                 twofish_decrypt(&ctx->key1, block, data);
1056
1057         for (i = 0; i < TWOFISH_XTS_BLOCK_LEN; i++)
1058                 data[i] ^= iv[i];
1059
1060         /* Exponentiate tweak */
1061         carry_in = 0;
1062         for (i = 0; i < TWOFISH_XTS_BLOCK_LEN; i++) {
1063                 carry_out = iv[i] & 0x80;
1064                 iv[i] = (iv[i] << 1) | (carry_in ? 1 : 0);
1065                 carry_in = carry_out;
1066         }
1067         if (carry_in)
1068                 iv[0] ^= AES_XTS_ALPHA;
1069         bzero(block, sizeof(block));
1070 }
1071
1072 void
1073 twofish_xts_encrypt(caddr_t key, u_int8_t *data, u_int8_t *iv)
1074 {
1075         twofish_xts_crypt((struct twofish_xts_ctx *)key, data, iv, 1);
1076 }
1077
1078 void
1079 twofish_xts_decrypt(caddr_t key, u_int8_t *data, u_int8_t *iv)
1080 {
1081         twofish_xts_crypt((struct twofish_xts_ctx *)key, data, iv, 0);
1082 }
1083
1084 int
1085 twofish_xts_setkey(u_int8_t **sched, u_int8_t *key, int len)
1086 {
1087         struct twofish_xts_ctx *ctx;
1088
1089         if (len != 32 && len != 64)
1090                 return -1;
1091
1092         *sched = kmalloc(sizeof(struct twofish_xts_ctx), M_CRYPTO_DATA,
1093             M_WAITOK | M_ZERO);
1094         ctx = (struct twofish_xts_ctx *)*sched;
1095
1096         twofish_set_key(&ctx->key1, key, len * 4);
1097         twofish_set_key(&ctx->key2, key + (len / 2), len * 4);
1098
1099         return 0;
1100 }
1101
1102 void
1103 twofish_xts_zerokey(u_int8_t **sched)
1104 {
1105         bzero(*sched, sizeof(struct twofish_xts_ctx));
1106         kfree(*sched, M_CRYPTO_DATA);
1107         *sched = NULL;
1108 }
1109
1110 struct serpent_xts_ctx {
1111         serpent_ctx key1;
1112         serpent_ctx key2;
1113 };
1114
1115 void
1116 serpent_xts_reinit(caddr_t key, u_int8_t *iv)
1117 {
1118         struct serpent_xts_ctx *ctx = (struct serpent_xts_ctx *)key;
1119 #if 0
1120         u_int64_t blocknum;
1121         u_int i;
1122 #endif
1123
1124 #if 0
1125         /*
1126          * Prepare tweak as E_k2(IV). IV is specified as LE representation
1127          * of a 64-bit block number which we allow to be passed in directly.
1128          */
1129         /* XXX: possibly use htole64? */
1130 #endif
1131         /* Last 64 bits of IV are always zero */
1132         bzero(iv + SERPENT_XTS_IV_LEN, SERPENT_XTS_IV_LEN);
1133
1134         serpent_encrypt(&ctx->key2, iv, iv);
1135 }
1136
1137 void
1138 serpent_xts_crypt(struct serpent_xts_ctx *ctx, u_int8_t *data, u_int8_t *iv,
1139     u_int do_encrypt)
1140 {
1141         u_int8_t block[SERPENT_XTS_BLOCK_LEN];
1142         u_int i, carry_in, carry_out;
1143
1144         for (i = 0; i < SERPENT_XTS_BLOCK_LEN; i++)
1145                 block[i] = data[i] ^ iv[i];
1146
1147         if (do_encrypt)
1148                 serpent_encrypt(&ctx->key1, block, data);
1149         else
1150                 serpent_decrypt(&ctx->key1, block, data);
1151
1152         for (i = 0; i < SERPENT_XTS_BLOCK_LEN; i++)
1153                 data[i] ^= iv[i];
1154
1155         /* Exponentiate tweak */
1156         carry_in = 0;
1157         for (i = 0; i < SERPENT_XTS_BLOCK_LEN; i++) {
1158                 carry_out = iv[i] & 0x80;
1159                 iv[i] = (iv[i] << 1) | (carry_in ? 1 : 0);
1160                 carry_in = carry_out;
1161         }
1162         if (carry_in)
1163                 iv[0] ^= AES_XTS_ALPHA;
1164         bzero(block, sizeof(block));
1165 }
1166
1167 void
1168 serpent_xts_encrypt(caddr_t key, u_int8_t *data, u_int8_t *iv)
1169 {
1170         serpent_xts_crypt((struct serpent_xts_ctx *)key, data, iv, 1);
1171 }
1172
1173 void
1174 serpent_xts_decrypt(caddr_t key, u_int8_t *data, u_int8_t *iv)
1175 {
1176         serpent_xts_crypt((struct serpent_xts_ctx *)key, data, iv, 0);
1177 }
1178
1179 int
1180 serpent_xts_setkey(u_int8_t **sched, u_int8_t *key, int len)
1181 {
1182         struct serpent_xts_ctx *ctx;
1183
1184         if (len != 32 && len != 64)
1185                 return -1;
1186
1187         *sched = kmalloc(sizeof(struct serpent_xts_ctx), M_CRYPTO_DATA,
1188             M_WAITOK | M_ZERO);
1189         ctx = (struct serpent_xts_ctx *)*sched;
1190
1191         serpent_set_key(&ctx->key1, key, len * 4);
1192         serpent_set_key(&ctx->key2, key + (len / 2), len * 4);
1193
1194         return 0;
1195 }
1196
1197 void
1198 serpent_xts_zerokey(u_int8_t **sched)
1199 {
1200         bzero(*sched, sizeof(struct serpent_xts_ctx));
1201         kfree(*sched, M_CRYPTO_DATA);
1202         *sched = NULL;
1203 }
1204
1205
1206 /*
1207  * And now for auth.
1208  */
1209
1210 static void
1211 null_init(void *ctx)
1212 {
1213 }
1214
1215 static int
1216 null_update(void *ctx, u_int8_t *buf, u_int16_t len)
1217 {
1218         return 0;
1219 }
1220
1221 static void
1222 null_final(u_int8_t *buf, void *ctx)
1223 {
1224         if (buf != NULL)
1225                 bzero(buf, 12);
1226 }
1227
1228 static int
1229 RMD160Update_int(void *ctx, u_int8_t *buf, u_int16_t len)
1230 {
1231         RMD160Update(ctx, buf, len);
1232         return 0;
1233 }
1234
1235 static int
1236 MD5Update_int(void *ctx, u_int8_t *buf, u_int16_t len)
1237 {
1238         MD5Update(ctx, buf, len);
1239         return 0;
1240 }
1241
1242 static void
1243 SHA1Init_int(void *ctx)
1244 {
1245         SHA1Init(ctx);
1246 }
1247
1248 static int
1249 SHA1Update_int(void *ctx, u_int8_t *buf, u_int16_t len)
1250 {
1251         SHA1Update(ctx, buf, len);
1252         return 0;
1253 }
1254
1255 static void
1256 SHA1Final_int(u_int8_t *blk, void *ctx)
1257 {
1258         SHA1Final(blk, ctx);
1259 }
1260
1261 static int
1262 SHA256Update_int(void *ctx, u_int8_t *buf, u_int16_t len)
1263 {
1264         SHA256_Update(ctx, buf, len);
1265         return 0;
1266 }
1267
1268 static int
1269 SHA384Update_int(void *ctx, u_int8_t *buf, u_int16_t len)
1270 {
1271         SHA384_Update(ctx, buf, len);
1272         return 0;
1273 }
1274
1275 static int
1276 SHA512Update_int(void *ctx, u_int8_t *buf, u_int16_t len)
1277 {
1278         SHA512_Update(ctx, buf, len);
1279         return 0;
1280 }
1281
1282 /*
1283  * And compression
1284  */
1285
1286 static u_int32_t
1287 deflate_compress(u_int8_t *data, u_int32_t size, u_int8_t **out)
1288 {
1289         return deflate_global(data, size, 0, out);
1290 }
1291
1292 static u_int32_t
1293 deflate_decompress(u_int8_t *data, u_int32_t size, u_int8_t **out)
1294 {
1295         return deflate_global(data, size, 1, out);
1296 }