Merge branch 'vendor/BINUTILS220'
[dragonfly.git] / 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 *, u_int8_t *);
66 static void null_decrypt(caddr_t, u_int8_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 *, u_int8_t *);
80 static  void des3_encrypt(caddr_t, u_int8_t *, u_int8_t *);
81 static  void blf_encrypt(caddr_t, u_int8_t *, u_int8_t *);
82 static  void cast5_encrypt(caddr_t, u_int8_t *, u_int8_t *);
83 static  void skipjack_encrypt(caddr_t, u_int8_t *, u_int8_t *);
84 static  void rijndael128_encrypt(caddr_t, u_int8_t *, u_int8_t *);
85 static  void aes_xts_encrypt(caddr_t, u_int8_t *, u_int8_t *);
86 static  void cml_encrypt(caddr_t, u_int8_t *, u_int8_t *);
87 static  void des1_decrypt(caddr_t, u_int8_t *, u_int8_t *);
88 static  void des3_decrypt(caddr_t, u_int8_t *, u_int8_t *);
89 static  void blf_decrypt(caddr_t, u_int8_t *, u_int8_t *);
90 static  void cast5_decrypt(caddr_t, u_int8_t *, u_int8_t *);
91 static  void skipjack_decrypt(caddr_t, u_int8_t *, u_int8_t *);
92 static  void rijndael128_decrypt(caddr_t, u_int8_t *, u_int8_t *);
93 static  void aes_xts_decrypt(caddr_t, u_int8_t *, u_int8_t *);
94 static  void cml_decrypt(caddr_t, u_int8_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 *, 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_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, u_int8_t *iv)
316 {
317 }
318 static void
319 null_decrypt(caddr_t key, u_int8_t *blk, u_int8_t *iv)
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, u_int8_t *iv)
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, u_int8_t *iv)
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, u_int8_t *iv)
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, u_int8_t *iv)
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, u_int8_t *iv)
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, u_int8_t *iv)
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, u_int8_t *iv)
476 {
477         cast_encrypt((cast_key *) key, blk, blk);
478 }
479
480 static void
481 cast5_decrypt(caddr_t key, u_int8_t *blk, u_int8_t *iv)
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, u_int8_t *iv)
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, u_int8_t *iv)
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, u_int8_t *iv)
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, u_int8_t *iv)
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 };
597
598 void
599 aes_xts_reinit(caddr_t key, u_int8_t *iv)
600 {
601         struct aes_xts_ctx *ctx = (struct aes_xts_ctx *)key;
602 #if 0
603         u_int64_t blocknum;
604         u_int i;
605 #endif
606
607 #if 0
608         /* 
609          * XXX: I've no idea why OpenBSD chose to make this dance of the moon
610          * around just copying the IV...
611          */
612         /*
613          * Prepare tweak as E_k2(IV). IV is specified as LE representation
614          * of a 64-bit block number which we allow to be passed in directly.
615          */
616         bcopy(iv, &blocknum, AES_XTS_IV_LEN);
617         for (i = 0; i < AES_XTS_IV_LEN; i++) {
618                 ctx->tweak[i] = blocknum & 0xff;
619                 blocknum >>= 8;
620         }
621 #endif
622         /* Last 64 bits of IV are always zero */
623         bzero(iv + AES_XTS_IV_LEN, AES_XTS_IV_LEN);
624
625         rijndael_encrypt(&ctx->key2, iv, iv);
626 }
627
628 void
629 aes_xts_crypt(struct aes_xts_ctx *ctx, u_int8_t *data, u_int8_t *iv, u_int do_encrypt)
630 {
631         u_int8_t block[AES_XTS_BLOCK_LEN];
632         u_int i, carry_in, carry_out;
633
634         for (i = 0; i < AES_XTS_BLOCK_LEN; i++)
635                 block[i] = data[i] ^ iv[i];
636
637         if (do_encrypt)
638                 rijndael_encrypt(&ctx->key1, block, data);
639         else
640                 rijndael_decrypt(&ctx->key1, block, data);
641
642         for (i = 0; i < AES_XTS_BLOCK_LEN; i++)
643                 data[i] ^= iv[i];
644
645         /* Exponentiate tweak */
646         carry_in = 0;
647         for (i = 0; i < AES_XTS_BLOCK_LEN; i++) {
648                 carry_out = iv[i] & 0x80;
649                 iv[i] = (iv[i] << 1) | (carry_in ? 1 : 0);
650                 carry_in = carry_out;
651         }
652         if (carry_in)
653                 iv[0] ^= AES_XTS_ALPHA;
654         bzero(block, sizeof(block));
655 }
656
657 void
658 aes_xts_encrypt(caddr_t key, u_int8_t *data, u_int8_t *iv)
659 {
660         aes_xts_crypt((struct aes_xts_ctx *)key, data, iv, 1);
661 }
662
663 void
664 aes_xts_decrypt(caddr_t key, u_int8_t *data, u_int8_t *iv)
665 {
666         aes_xts_crypt((struct aes_xts_ctx *)key, data, iv, 0);
667 }
668
669 int
670 aes_xts_setkey(u_int8_t **sched, u_int8_t *key, int len)
671 {
672         struct aes_xts_ctx *ctx;
673         
674         if (len != 32 && len != 64)
675                 return -1;
676         
677         *sched = kmalloc(sizeof(struct aes_xts_ctx), M_CRYPTO_DATA,
678             M_WAITOK | M_ZERO);
679         ctx = (struct aes_xts_ctx *)*sched;
680         
681         rijndael_set_key(&ctx->key1, key, len * 4);
682         rijndael_set_key(&ctx->key2, key + (len / 2), len * 4);
683         
684         return 0;
685 }
686
687 void
688 aes_xts_zerokey(u_int8_t **sched)
689 {
690         bzero(*sched, sizeof(struct aes_xts_ctx));
691         kfree(*sched, M_CRYPTO_DATA);
692         *sched = NULL;
693 }
694
695 #define AESCTR_NONCESIZE        4
696
697 struct aes_ctr_ctx {
698         u_int32_t       ac_ek[4*(14 + 1)];
699         u_int8_t        ac_block[AESCTR_BLOCK_LEN];
700         int             ac_nr;
701 };
702
703 void
704 aes_ctr_reinit(caddr_t key, u_int8_t *iv)
705 {
706         struct aes_ctr_ctx *ctx;
707
708         ctx = (struct aes_ctr_ctx *)key;
709         bcopy(iv, iv + AESCTR_NONCESIZE, AESCTR_IV_LEN);
710         bcopy(ctx->ac_block, iv, AESCTR_NONCESIZE);
711
712         /* reset counter */
713         bzero(iv + AESCTR_NONCESIZE + AESCTR_IV_LEN, 4);
714 }
715
716 void
717 aes_ctr_crypt(caddr_t key, u_int8_t *data, u_int8_t *iv)
718 {
719         struct aes_ctr_ctx *ctx;
720         u_int8_t keystream[AESCTR_BLOCK_LEN];
721         int i;
722
723         ctx = (struct aes_ctr_ctx *)key;
724         /* increment counter */
725         for (i = AESCTR_BLOCK_LEN - 1;
726         i >= AESCTR_NONCESIZE + AESCTR_IV_LEN; i--)
727                 if (++iv[i])   /* continue on overflow */
728                         break;
729         rijndaelEncrypt(ctx->ac_ek, ctx->ac_nr, iv, keystream);
730         for (i = 0; i < AESCTR_BLOCK_LEN; i++)
731                 data[i] ^= keystream[i];
732 }
733
734 int
735 aes_ctr_setkey(u_int8_t **sched, u_int8_t *key, int len)
736 {
737         struct aes_ctr_ctx *ctx;
738
739         if (len < AESCTR_NONCESIZE)
740                 return -1;
741
742         *sched = kmalloc(sizeof(struct aes_ctr_ctx), M_CRYPTO_DATA,
743         M_WAITOK | M_ZERO);
744         ctx = (struct aes_ctr_ctx *)*sched;
745         ctx->ac_nr = rijndaelKeySetupEnc(ctx->ac_ek, (u_char *)key,
746         (len - AESCTR_NONCESIZE) * 8);
747         if (ctx->ac_nr == 0) {
748                 aes_ctr_zerokey(sched);
749                 return -1;
750         }
751         bcopy(key + len - AESCTR_NONCESIZE, ctx->ac_block, AESCTR_NONCESIZE);
752         return 0;
753 }
754
755 void
756 aes_ctr_zerokey(u_int8_t **sched)
757 {
758         bzero(*sched, sizeof(struct aes_ctr_ctx));
759         kfree(*sched, M_CRYPTO_DATA);
760         *sched = NULL;
761 }
762
763 static void
764 cml_encrypt(caddr_t key, u_int8_t *blk, u_int8_t *iv)
765 {
766         camellia_encrypt((camellia_ctx *) key, (u_char *) blk, (u_char *) blk);
767 }
768
769 static void
770 cml_decrypt(caddr_t key, u_int8_t *blk, u_int8_t *iv)
771 {
772         camellia_decrypt(((camellia_ctx *) key), (u_char *) blk,
773             (u_char *) blk);
774 }
775
776 static int
777 cml_setkey(u_int8_t **sched, u_int8_t *key, int len)
778 {
779         int err;
780
781         if (len != 16 && len != 24 && len != 32)
782                 return (EINVAL);
783         *sched = kmalloc(sizeof(camellia_ctx), M_CRYPTO_DATA,
784                          M_INTWAIT | M_ZERO);
785         if (*sched != NULL) {
786                 camellia_set_key((camellia_ctx *) *sched, (u_char *) key,
787                     len * 8);
788                 err = 0;
789         } else
790                 err = ENOMEM;
791         return err;
792 }
793
794 static void
795 cml_zerokey(u_int8_t **sched)
796 {
797         bzero(*sched, sizeof(camellia_ctx));
798         kfree(*sched, M_CRYPTO_DATA);
799         *sched = NULL;
800 }
801
802 /*
803  * And now for auth.
804  */
805
806 static void
807 null_init(void *ctx)
808 {
809 }
810
811 static int
812 null_update(void *ctx, u_int8_t *buf, u_int16_t len)
813 {
814         return 0;
815 }
816
817 static void
818 null_final(u_int8_t *buf, void *ctx)
819 {
820         if (buf != NULL)
821                 bzero(buf, 12);
822 }
823
824 static int
825 RMD160Update_int(void *ctx, u_int8_t *buf, u_int16_t len)
826 {
827         RMD160Update(ctx, buf, len);
828         return 0;
829 }
830
831 static int
832 MD5Update_int(void *ctx, u_int8_t *buf, u_int16_t len)
833 {
834         MD5Update(ctx, buf, len);
835         return 0;
836 }
837
838 static void
839 SHA1Init_int(void *ctx)
840 {
841         SHA1Init(ctx);
842 }
843
844 static int
845 SHA1Update_int(void *ctx, u_int8_t *buf, u_int16_t len)
846 {
847         SHA1Update(ctx, buf, len);
848         return 0;
849 }
850
851 static void
852 SHA1Final_int(u_int8_t *blk, void *ctx)
853 {
854         SHA1Final(blk, ctx);
855 }
856
857 static int
858 SHA256Update_int(void *ctx, u_int8_t *buf, u_int16_t len)
859 {
860         SHA256_Update(ctx, buf, len);
861         return 0;
862 }
863
864 static int
865 SHA384Update_int(void *ctx, u_int8_t *buf, u_int16_t len)
866 {
867         SHA384_Update(ctx, buf, len);
868         return 0;
869 }
870
871 static int
872 SHA512Update_int(void *ctx, u_int8_t *buf, u_int16_t len)
873 {
874         SHA512_Update(ctx, buf, len);
875         return 0;
876 }
877
878 /*
879  * And compression
880  */
881
882 static u_int32_t
883 deflate_compress(u_int8_t *data, u_int32_t size, u_int8_t **out)
884 {
885         return deflate_global(data, size, 0, out);
886 }
887
888 static u_int32_t
889 deflate_decompress(u_int8_t *data, u_int32_t size, u_int8_t **out)
890 {
891         return deflate_global(data, size, 1, out);
892 }