Annotation of sys/crypto/xform.c, Revision 1.1.1.1
1.1 nbrk 1: /* $OpenBSD: xform.c,v 1.31 2007/05/27 05:43:17 tedu 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/param.h>
40: #include <sys/systm.h>
41: #include <sys/malloc.h>
42: #include <sys/sysctl.h>
43: #include <sys/errno.h>
44: #include <sys/time.h>
45: #include <sys/kernel.h>
46: #include <machine/cpu.h>
47:
48: #include <crypto/md5.h>
49: #include <crypto/sha1.h>
50: #include <crypto/sha2.h>
51: #include <crypto/rmd160.h>
52: #include <crypto/blf.h>
53: #include <crypto/cast.h>
54: #include <crypto/skipjack.h>
55: #include <crypto/rijndael.h>
56: #include <crypto/cryptodev.h>
57: #include <crypto/xform.h>
58: #include <crypto/deflate.h>
59:
60: extern void des_ecb3_encrypt(caddr_t, caddr_t, caddr_t, caddr_t, caddr_t, int);
61: extern void des_ecb_encrypt(caddr_t, caddr_t, caddr_t, int);
62:
63: int des_set_key(caddr_t, caddr_t);
64: int des1_setkey(u_int8_t **, u_int8_t *, int);
65: int des3_setkey(u_int8_t **, u_int8_t *, int);
66: int blf_setkey(u_int8_t **, u_int8_t *, int);
67: int cast5_setkey(u_int8_t **, u_int8_t *, int);
68: int skipjack_setkey(u_int8_t **, u_int8_t *, int);
69: int rijndael128_setkey(u_int8_t **, u_int8_t *, int);
70: int aes_ctr_setkey(u_int8_t **, u_int8_t *, int);
71: void des1_encrypt(caddr_t, u_int8_t *);
72: void des3_encrypt(caddr_t, u_int8_t *);
73: void blf_encrypt(caddr_t, u_int8_t *);
74: void cast5_encrypt(caddr_t, u_int8_t *);
75: void skipjack_encrypt(caddr_t, u_int8_t *);
76: void rijndael128_encrypt(caddr_t, u_int8_t *);
77: void des1_decrypt(caddr_t, u_int8_t *);
78: void des3_decrypt(caddr_t, u_int8_t *);
79: void blf_decrypt(caddr_t, u_int8_t *);
80: void cast5_decrypt(caddr_t, u_int8_t *);
81: void skipjack_decrypt(caddr_t, u_int8_t *);
82: void rijndael128_decrypt(caddr_t, u_int8_t *);
83: void des1_zerokey(u_int8_t **);
84: void des3_zerokey(u_int8_t **);
85: void blf_zerokey(u_int8_t **);
86: void cast5_zerokey(u_int8_t **);
87: void skipjack_zerokey(u_int8_t **);
88: void rijndael128_zerokey(u_int8_t **);
89: void aes_ctr_zerokey(u_int8_t **);
90: void null_encrypt(caddr_t, u_int8_t *);
91: void null_zerokey(u_int8_t **);
92: int null_setkey(u_int8_t **, u_int8_t *, int);
93: void null_decrypt(caddr_t, u_int8_t *);
94:
95: void aes_ctr_reinit(caddr_t, u_int8_t *);
96: void aes_ctr_crypt(caddr_t, u_int8_t *);
97:
98: int MD5Update_int(void *, u_int8_t *, u_int16_t);
99: int SHA1Update_int(void *, u_int8_t *, u_int16_t);
100: int RMD160Update_int(void *, u_int8_t *, u_int16_t);
101: int SHA256_Update_int(void *, u_int8_t *, u_int16_t);
102: int SHA384_Update_int(void *, u_int8_t *, u_int16_t);
103: int SHA512_Update_int(void *, u_int8_t *, u_int16_t);
104:
105: u_int32_t deflate_compress(u_int8_t *, u_int32_t, u_int8_t **);
106: u_int32_t deflate_decompress(u_int8_t *, u_int32_t, u_int8_t **);
107: u_int32_t lzs_dummy(u_int8_t *, u_int32_t, u_int8_t **);
108:
109: /* Encryption instances */
110: struct enc_xform enc_xform_des = {
111: CRYPTO_DES_CBC, "DES",
112: 8, 8, 8, 8,
113: des1_encrypt,
114: des1_decrypt,
115: des1_setkey,
116: des1_zerokey,
117: NULL
118: };
119:
120: struct enc_xform enc_xform_3des = {
121: CRYPTO_3DES_CBC, "3DES",
122: 8, 8, 24, 24,
123: des3_encrypt,
124: des3_decrypt,
125: des3_setkey,
126: des3_zerokey,
127: NULL
128: };
129:
130: struct enc_xform enc_xform_blf = {
131: CRYPTO_BLF_CBC, "Blowfish",
132: 8, 8, 5, 56 /* 448 bits, max key */,
133: blf_encrypt,
134: blf_decrypt,
135: blf_setkey,
136: blf_zerokey,
137: NULL
138: };
139:
140: struct enc_xform enc_xform_cast5 = {
141: CRYPTO_CAST_CBC, "CAST-128",
142: 8, 8, 5, 16,
143: cast5_encrypt,
144: cast5_decrypt,
145: cast5_setkey,
146: cast5_zerokey,
147: NULL
148: };
149:
150: struct enc_xform enc_xform_skipjack = {
151: CRYPTO_SKIPJACK_CBC, "Skipjack",
152: 8, 8, 10, 10,
153: skipjack_encrypt,
154: skipjack_decrypt,
155: skipjack_setkey,
156: skipjack_zerokey,
157: NULL
158: };
159:
160: struct enc_xform enc_xform_rijndael128 = {
161: CRYPTO_RIJNDAEL128_CBC, "Rijndael-128/AES",
162: 16, 16, 16, 32,
163: rijndael128_encrypt,
164: rijndael128_decrypt,
165: rijndael128_setkey,
166: rijndael128_zerokey,
167: NULL
168: };
169:
170: struct enc_xform enc_xform_aes_ctr = {
171: CRYPTO_AES_CTR, "AES-CTR",
172: 16, 8, 16+4, 32+4,
173: aes_ctr_crypt,
174: NULL,
175: aes_ctr_setkey,
176: aes_ctr_zerokey,
177: aes_ctr_reinit
178: };
179:
180: struct enc_xform enc_xform_arc4 = {
181: CRYPTO_ARC4, "ARC4",
182: 1, 1, 1, 32,
183: NULL,
184: NULL,
185: NULL,
186: NULL,
187: NULL
188: };
189:
190: struct enc_xform enc_xform_null = {
191: CRYPTO_NULL, "NULL",
192: 4, 0, 0, 256,
193: null_encrypt,
194: null_decrypt,
195: null_setkey,
196: null_zerokey,
197: NULL
198: };
199:
200: /* Authentication instances */
201: struct auth_hash auth_hash_hmac_md5_96 = {
202: CRYPTO_MD5_HMAC, "HMAC-MD5",
203: 16, 16, 12, sizeof(MD5_CTX),
204: (void (*) (void *)) MD5Init, MD5Update_int,
205: (void (*) (u_int8_t *, void *)) MD5Final
206: };
207:
208: struct auth_hash auth_hash_hmac_sha1_96 = {
209: CRYPTO_SHA1_HMAC, "HMAC-SHA1",
210: 20, 20, 12, sizeof(SHA1_CTX),
211: (void (*) (void *)) SHA1Init, SHA1Update_int,
212: (void (*) (u_int8_t *, void *)) SHA1Final
213: };
214:
215: struct auth_hash auth_hash_hmac_ripemd_160_96 = {
216: CRYPTO_RIPEMD160_HMAC, "HMAC-RIPEMD-160",
217: 20, 20, 12, sizeof(RMD160_CTX),
218: (void (*)(void *)) RMD160Init, RMD160Update_int,
219: (void (*)(u_int8_t *, void *)) RMD160Final
220: };
221:
222: struct auth_hash auth_hash_hmac_sha2_256_96 = {
223: CRYPTO_SHA2_256_HMAC, "HMAC-SHA2-256",
224: 32, 32, 12, sizeof(SHA256_CTX),
225: (void (*)(void *)) SHA256_Init, SHA256_Update_int,
226: (void (*)(u_int8_t *, void *)) SHA256_Final
227: };
228:
229: struct auth_hash auth_hash_hmac_sha2_384_96 = {
230: CRYPTO_SHA2_384_HMAC, "HMAC-SHA2-384",
231: 48, 48, 12, sizeof(SHA384_CTX),
232: (void (*)(void *)) SHA384_Init, SHA384_Update_int,
233: (void (*)(u_int8_t *, void *)) SHA384_Final
234: };
235:
236: struct auth_hash auth_hash_hmac_sha2_512_96 = {
237: CRYPTO_SHA2_512_HMAC, "HMAC-SHA2-512",
238: 64, 64, 12, sizeof(SHA512_CTX),
239: (void (*)(void *)) SHA512_Init, SHA512_Update_int,
240: (void (*)(u_int8_t *, void *)) SHA512_Final
241: };
242:
243: struct auth_hash auth_hash_key_md5 = {
244: CRYPTO_MD5_KPDK, "Keyed MD5",
245: 0, 16, 16, sizeof(MD5_CTX),
246: (void (*)(void *)) MD5Init, MD5Update_int,
247: (void (*)(u_int8_t *, void *)) MD5Final
248: };
249:
250: struct auth_hash auth_hash_key_sha1 = {
251: CRYPTO_SHA1_KPDK, "Keyed SHA1",
252: 0, 20, 20, sizeof(SHA1_CTX),
253: (void (*)(void *)) SHA1Init, SHA1Update_int,
254: (void (*)(u_int8_t *, void *)) SHA1Final
255: };
256:
257: struct auth_hash auth_hash_md5 = {
258: CRYPTO_MD5, "MD5",
259: 0, 16, 16, sizeof(MD5_CTX),
260: (void (*) (void *)) MD5Init, MD5Update_int,
261: (void (*) (u_int8_t *, void *)) MD5Final
262: };
263:
264: struct auth_hash auth_hash_sha1 = {
265: CRYPTO_SHA1, "SHA1",
266: 0, 20, 20, sizeof(SHA1_CTX),
267: (void (*)(void *)) SHA1Init, SHA1Update_int,
268: (void (*)(u_int8_t *, void *)) SHA1Final
269: };
270:
271: /* Compression instance */
272: struct comp_algo comp_algo_deflate = {
273: CRYPTO_DEFLATE_COMP, "Deflate",
274: 90, deflate_compress,
275: deflate_decompress
276: };
277:
278: struct comp_algo comp_algo_lzs = {
279: CRYPTO_LZS_COMP, "LZS",
280: 90, lzs_dummy,
281: lzs_dummy
282: };
283:
284: /*
285: * Encryption wrapper routines.
286: */
287: void
288: des1_encrypt(caddr_t key, u_int8_t *blk)
289: {
290: des_ecb_encrypt(blk, blk, key, 1);
291: }
292:
293: void
294: des1_decrypt(caddr_t key, u_int8_t *blk)
295: {
296: des_ecb_encrypt(blk, blk, key, 0);
297: }
298:
299: int
300: des1_setkey(u_int8_t **sched, u_int8_t *key, int len)
301: {
302: MALLOC(*sched, u_int8_t *, 128, M_CRYPTO_DATA, M_WAITOK);
303: bzero(*sched, 128);
304:
305: if (des_set_key(key, *sched) < 0) {
306: des1_zerokey(sched);
307: return -1;
308: }
309:
310: return 0;
311: }
312:
313: void
314: des1_zerokey(u_int8_t **sched)
315: {
316: bzero(*sched, 128);
317: FREE(*sched, M_CRYPTO_DATA);
318: *sched = NULL;
319: }
320:
321: void
322: des3_encrypt(caddr_t key, u_int8_t *blk)
323: {
324: des_ecb3_encrypt(blk, blk, key, key + 128, key + 256, 1);
325: }
326:
327: void
328: des3_decrypt(caddr_t key, u_int8_t *blk)
329: {
330: des_ecb3_encrypt(blk, blk, key + 256, key + 128, key, 0);
331: }
332:
333: int
334: des3_setkey(u_int8_t **sched, u_int8_t *key, int len)
335: {
336: MALLOC(*sched, u_int8_t *, 384, M_CRYPTO_DATA, M_WAITOK);
337: bzero(*sched, 384);
338:
339: if (des_set_key(key, *sched) < 0 || des_set_key(key + 8, *sched + 128)
340: < 0 || des_set_key(key + 16, *sched + 256) < 0) {
341: des3_zerokey(sched);
342: return -1;
343: }
344:
345: return 0;
346: }
347:
348: void
349: des3_zerokey(u_int8_t **sched)
350: {
351: bzero(*sched, 384);
352: FREE(*sched, M_CRYPTO_DATA);
353: *sched = NULL;
354: }
355:
356: void
357: blf_encrypt(caddr_t key, u_int8_t *blk)
358: {
359: blf_ecb_encrypt((blf_ctx *) key, blk, 8);
360: }
361:
362: void
363: blf_decrypt(caddr_t key, u_int8_t *blk)
364: {
365: blf_ecb_decrypt((blf_ctx *) key, blk, 8);
366: }
367:
368: int
369: blf_setkey(u_int8_t **sched, u_int8_t *key, int len)
370: {
371: MALLOC(*sched, u_int8_t *, sizeof(blf_ctx), M_CRYPTO_DATA, M_WAITOK);
372: bzero(*sched, sizeof(blf_ctx));
373: blf_key((blf_ctx *)*sched, key, len);
374:
375: return 0;
376: }
377:
378: void
379: blf_zerokey(u_int8_t **sched)
380: {
381: bzero(*sched, sizeof(blf_ctx));
382: FREE(*sched, M_CRYPTO_DATA);
383: *sched = NULL;
384: }
385:
386: int
387: null_setkey(u_int8_t **sched, u_int8_t *key, int len)
388: {
389: return 0;
390: }
391:
392: void
393: null_zerokey(u_int8_t **sched)
394: {
395: }
396:
397: void
398: null_encrypt(caddr_t key, u_int8_t *blk)
399: {
400: }
401:
402: void
403: null_decrypt(caddr_t key, u_int8_t *blk)
404: {
405: }
406:
407: void
408: cast5_encrypt(caddr_t key, u_int8_t *blk)
409: {
410: cast_encrypt((cast_key *) key, blk, blk);
411: }
412:
413: void
414: cast5_decrypt(caddr_t key, u_int8_t *blk)
415: {
416: cast_decrypt((cast_key *) key, blk, blk);
417: }
418:
419: int
420: cast5_setkey(u_int8_t **sched, u_int8_t *key, int len)
421: {
422: MALLOC(*sched, u_int8_t *, sizeof(cast_key), M_CRYPTO_DATA, M_WAITOK);
423: bzero(*sched, sizeof(cast_key));
424: cast_setkey((cast_key *)*sched, key, len);
425:
426: return 0;
427: }
428:
429: void
430: cast5_zerokey(u_int8_t **sched)
431: {
432: bzero(*sched, sizeof(cast_key));
433: FREE(*sched, M_CRYPTO_DATA);
434: *sched = NULL;
435: }
436:
437: void
438: skipjack_encrypt(caddr_t key, u_int8_t *blk)
439: {
440: skipjack_forwards(blk, blk, (u_int8_t **) key);
441: }
442:
443: void
444: skipjack_decrypt(caddr_t key, u_int8_t *blk)
445: {
446: skipjack_backwards(blk, blk, (u_int8_t **) key);
447: }
448:
449: int
450: skipjack_setkey(u_int8_t **sched, u_int8_t *key, int len)
451: {
452: MALLOC(*sched, u_int8_t *, 10 * sizeof(u_int8_t *), M_CRYPTO_DATA,
453: M_WAITOK);
454: bzero(*sched, 10 * sizeof(u_int8_t *));
455: subkey_table_gen(key, (u_int8_t **) *sched);
456:
457: return 0;
458: }
459:
460: void
461: skipjack_zerokey(u_int8_t **sched)
462: {
463: int k;
464:
465: for (k = 0; k < 10; k++) {
466: if (((u_int8_t **)(*sched))[k]) {
467: bzero(((u_int8_t **)(*sched))[k], 0x100);
468: FREE(((u_int8_t **)(*sched))[k], M_CRYPTO_DATA);
469: }
470: }
471: bzero(*sched, 10 * sizeof(u_int8_t *));
472: FREE(*sched, M_CRYPTO_DATA);
473: *sched = NULL;
474: }
475:
476: void
477: rijndael128_encrypt(caddr_t key, u_int8_t *blk)
478: {
479: rijndael_encrypt((rijndael_ctx *) key, (u_char *) blk, (u_char *) blk);
480: }
481:
482: void
483: rijndael128_decrypt(caddr_t key, u_int8_t *blk)
484: {
485: rijndael_decrypt((rijndael_ctx *) key, (u_char *) blk, (u_char *) blk);
486: }
487:
488: int
489: rijndael128_setkey(u_int8_t **sched, u_int8_t *key, int len)
490: {
491: MALLOC(*sched, u_int8_t *, sizeof(rijndael_ctx), M_CRYPTO_DATA,
492: M_WAITOK);
493: bzero(*sched, sizeof(rijndael_ctx));
494:
495: if (rijndael_set_key((rijndael_ctx *)*sched, (u_char *)key, len * 8)
496: < 0) {
497: rijndael128_zerokey(sched);
498: return -1;
499: }
500:
501: return 0;
502: }
503:
504: void
505: rijndael128_zerokey(u_int8_t **sched)
506: {
507: bzero(*sched, sizeof(rijndael_ctx));
508: FREE(*sched, M_CRYPTO_DATA);
509: *sched = NULL;
510: }
511:
512: #define AESCTR_NONCESIZE 4
513: #define AESCTR_IVSIZE 8
514: #define AESCTR_BLOCKSIZE 16
515:
516: struct aes_ctr_ctx {
517: u_int32_t ac_ek[4*(AES_MAXROUNDS + 1)];
518: u_int8_t ac_block[AESCTR_BLOCKSIZE];
519: int ac_nr;
520: };
521:
522: void
523: aes_ctr_reinit(caddr_t key, u_int8_t *iv)
524: {
525: struct aes_ctr_ctx *ctx;
526:
527: ctx = (struct aes_ctr_ctx *)key;
528: bcopy(iv, ctx->ac_block + AESCTR_NONCESIZE, AESCTR_IVSIZE);
529:
530: /* reset counter */
531: bzero(ctx->ac_block + AESCTR_NONCESIZE + AESCTR_IVSIZE, 4);
532: }
533:
534: void
535: aes_ctr_crypt(caddr_t key, u_int8_t *data)
536: {
537: struct aes_ctr_ctx *ctx;
538: u_int8_t keystream[AESCTR_BLOCKSIZE];
539: int i;
540:
541: ctx = (struct aes_ctr_ctx *)key;
542: /* increment counter */
543: for (i = AESCTR_BLOCKSIZE - 1;
544: i >= AESCTR_NONCESIZE + AESCTR_IVSIZE; i--)
545: if (++ctx->ac_block[i]) /* continue on overflow */
546: break;
547: rijndaelEncrypt(ctx->ac_ek, ctx->ac_nr, ctx->ac_block, keystream);
548: for (i = 0; i < AESCTR_BLOCKSIZE; i++)
549: data[i] ^= keystream[i];
550: }
551:
552: int
553: aes_ctr_setkey(u_int8_t **sched, u_int8_t *key, int len)
554: {
555: struct aes_ctr_ctx *ctx;
556:
557: if (len < AESCTR_NONCESIZE)
558: return -1;
559:
560: MALLOC(*sched, u_int8_t *, sizeof(struct aes_ctr_ctx), M_CRYPTO_DATA,
561: M_WAITOK);
562: bzero(*sched, sizeof(struct aes_ctr_ctx));
563: ctx = (struct aes_ctr_ctx *)*sched;
564: ctx->ac_nr = rijndaelKeySetupEnc(ctx->ac_ek, (u_char *)key,
565: (len - AESCTR_NONCESIZE) * 8);
566: if (ctx->ac_nr == 0) {
567: aes_ctr_zerokey(sched);
568: return -1;
569: }
570: bcopy(key + len - AESCTR_NONCESIZE, ctx->ac_block, AESCTR_NONCESIZE);
571: return 0;
572: }
573:
574: void
575: aes_ctr_zerokey(u_int8_t **sched)
576: {
577: bzero(*sched, sizeof(struct aes_ctr_ctx));
578: FREE(*sched, M_CRYPTO_DATA);
579: *sched = NULL;
580: }
581:
582: /*
583: * And now for auth.
584: */
585:
586: int
587: RMD160Update_int(void *ctx, u_int8_t *buf, u_int16_t len)
588: {
589: RMD160Update(ctx, buf, len);
590: return 0;
591: }
592:
593: int
594: MD5Update_int(void *ctx, u_int8_t *buf, u_int16_t len)
595: {
596: MD5Update(ctx, buf, len);
597: return 0;
598: }
599:
600: int
601: SHA1Update_int(void *ctx, u_int8_t *buf, u_int16_t len)
602: {
603: SHA1Update(ctx, buf, len);
604: return 0;
605: }
606:
607: int
608: SHA256_Update_int(void *ctx, u_int8_t *buf, u_int16_t len)
609: {
610: SHA256_Update(ctx, buf, len);
611: return 0;
612: }
613:
614: int
615: SHA384_Update_int(void *ctx, u_int8_t *buf, u_int16_t len)
616: {
617: SHA384_Update(ctx, buf, len);
618: return 0;
619: }
620:
621: int
622: SHA512_Update_int(void *ctx, u_int8_t *buf, u_int16_t len)
623: {
624: SHA512_Update(ctx, buf, len);
625: return 0;
626: }
627:
628: /*
629: * And compression
630: */
631:
632: u_int32_t
633: deflate_compress(u_int8_t *data, u_int32_t size, u_int8_t **out)
634: {
635: return deflate_global(data, size, 0, out);
636: }
637:
638: u_int32_t
639: deflate_decompress(u_int8_t *data, u_int32_t size, u_int8_t **out)
640: {
641: return deflate_global(data, size, 1, out);
642: }
643:
644: u_int32_t
645: lzs_dummy(u_int8_t *data, u_int32_t size, u_int8_t **out)
646: {
647: *out = NULL;
648: return (0);
649: }
CVSweb
![[BACK]](/icons/back.gif){kind=icon}
Return to xform.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / sys / crypto