root/crypto/xform.c

DEFINITIONS

1. des1_encrypt
2. des1_decrypt
3. des1_setkey
4. des1_zerokey
5. des3_encrypt
6. des3_decrypt
7. des3_setkey
8. des3_zerokey
9. blf_encrypt
10. blf_decrypt
11. blf_setkey
12. blf_zerokey
13. null_setkey
14. null_zerokey
15. null_encrypt
16. null_decrypt
17. cast5_encrypt
18. cast5_decrypt
19. cast5_setkey
20. cast5_zerokey
21. skipjack_encrypt
22. skipjack_decrypt
23. skipjack_setkey
24. skipjack_zerokey
25. rijndael128_encrypt
26. rijndael128_decrypt
27. rijndael128_setkey
28. rijndael128_zerokey
29. aes_ctr_reinit
30. aes_ctr_crypt
31. aes_ctr_setkey
32. aes_ctr_zerokey
33. RMD160Update_int
34. MD5Update_int
35. SHA1Update_int
36. SHA256_Update_int
37. SHA384_Update_int
38. SHA512_Update_int
39. deflate_compress
40. deflate_decompress
41. lzs_dummy

    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  */
   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>
   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>
   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);
   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 *);
   95 void aes_ctr_reinit(caddr_t, u_int8_t *);
   96 void aes_ctr_crypt(caddr_t, u_int8_t *);
   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);
u_int32_t deflate_compress(u_int8_t *, u_int32_t, u_int8_t **);
u_int32_t deflate_decompress(u_int8_t *, u_int32_t, u_int8_t **);
u_int32_t lzs_dummy(u_int8_t *, u_int32_t, u_int8_t **);
  109 /* Encryption instances */
  110 struct enc_xform enc_xform_des = {
CRYPTO_DES_CBC, "DES",
  112         8, 8, 8, 8,
des1_encrypt,
des1_decrypt,
des1_setkey,
des1_zerokey,
NULL
  118 };
  120 struct enc_xform enc_xform_3des = {
CRYPTO_3DES_CBC, "3DES",
  122         8, 8, 24, 24,
des3_encrypt,
des3_decrypt,
des3_setkey,
des3_zerokey,
NULL
  128 };
  130 struct enc_xform enc_xform_blf = {
CRYPTO_BLF_CBC, "Blowfish",
  132         8, 8, 5, 56 /* 448 bits, max key */,
blf_encrypt,
blf_decrypt,
blf_setkey,
blf_zerokey,
NULL
  138 };
  140 struct enc_xform enc_xform_cast5 = {
CRYPTO_CAST_CBC, "CAST-128",
  142         8, 8, 5, 16,
cast5_encrypt,
cast5_decrypt,
cast5_setkey,
cast5_zerokey,
NULL
  148 };
  150 struct enc_xform enc_xform_skipjack = {
CRYPTO_SKIPJACK_CBC, "Skipjack",
  152         8, 8, 10, 10,
skipjack_encrypt,
skipjack_decrypt,
skipjack_setkey,
skipjack_zerokey,
NULL
  158 };
  160 struct enc_xform enc_xform_rijndael128 = {
CRYPTO_RIJNDAEL128_CBC, "Rijndael-128/AES",
  162         16, 16, 16, 32,
rijndael128_encrypt,
rijndael128_decrypt,
rijndael128_setkey,
rijndael128_zerokey,
NULL
  168 };
  170 struct enc_xform enc_xform_aes_ctr = {
CRYPTO_AES_CTR, "AES-CTR",
  172         16, 8, 16+4, 32+4,
aes_ctr_crypt,
NULL,
aes_ctr_setkey,
aes_ctr_zerokey,
aes_ctr_reinit
  178 };
  180 struct enc_xform enc_xform_arc4 = {
CRYPTO_ARC4, "ARC4",
  182         1, 1, 1, 32,
NULL,
NULL,
NULL,
NULL,
NULL
  188 };
  190 struct enc_xform enc_xform_null = {
CRYPTO_NULL, "NULL",
  192         4, 0, 0, 256,
null_encrypt,
null_decrypt,
null_setkey,
null_zerokey,
NULL
  198 };
  200 /* Authentication instances */
  201 struct auth_hash auth_hash_hmac_md5_96 = {
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 };
  208 struct auth_hash auth_hash_hmac_sha1_96 = {
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 };
  215 struct auth_hash auth_hash_hmac_ripemd_160_96 = {
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 };
  222 struct auth_hash auth_hash_hmac_sha2_256_96 = {
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 };
  229 struct auth_hash auth_hash_hmac_sha2_384_96 = {
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 };
  236 struct auth_hash auth_hash_hmac_sha2_512_96 = {
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 };
  243 struct auth_hash auth_hash_key_md5 = {
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 };
  250 struct auth_hash auth_hash_key_sha1 = {
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 };
  257 struct auth_hash auth_hash_md5 = {
CRYPTO_MD5, "MD5",
  259         0, 16, 16, sizeof(MD5_CTX),
  260         (void (*) (void *)) MD5Init, MD5Update_int,
  261         (void (*) (u_int8_t *, void *)) MD5Final
  262 };
  264 struct auth_hash auth_hash_sha1 = {
CRYPTO_SHA1, "SHA1",
  266         0, 20, 20, sizeof(SHA1_CTX),
  267         (void (*)(void *)) SHA1Init, SHA1Update_int,
  268         (void (*)(u_int8_t *, void *)) SHA1Final
  269 };
  271 /* Compression instance */
  272 struct comp_algo comp_algo_deflate = {
CRYPTO_DEFLATE_COMP, "Deflate",
  274         90, deflate_compress,
deflate_decompress
  276 };
  278 struct comp_algo comp_algo_lzs = {
CRYPTO_LZS_COMP, "LZS",
  280         90, lzs_dummy,
lzs_dummy
  282 };
  284 /*
  285  * Encryption wrapper routines.
  286  */
  287 void
des1_encrypt(caddr_t key, u_int8_t *blk)
  289 {
des_ecb_encrypt(blk, blk, key, 1);
  291 }
  293 void
des1_decrypt(caddr_t key, u_int8_t *blk)
  295 {
des_ecb_encrypt(blk, blk, key, 0);
  297 }
  299 int
des1_setkey(u_int8_t **sched, u_int8_t *key, int len)
  301 {
MALLOC(*sched, u_int8_t *, 128, M_CRYPTO_DATA, M_WAITOK);
bzero(*sched, 128);
  305         if (des_set_key(key, *sched) < 0) {
des1_zerokey(sched);
  307                 return -1;
  308         }
  310         return 0;
  311 }
  313 void
des1_zerokey(u_int8_t **sched)
  315 {
bzero(*sched, 128);
FREE(*sched, M_CRYPTO_DATA);
  318         *sched = NULL;
  319 }
  321 void
des3_encrypt(caddr_t key, u_int8_t *blk)
  323 {
des_ecb3_encrypt(blk, blk, key, key + 128, key + 256, 1);
  325 }
  327 void
des3_decrypt(caddr_t key, u_int8_t *blk)
  329 {
des_ecb3_encrypt(blk, blk, key + 256, key + 128, key, 0);
  331 }
  333 int
des3_setkey(u_int8_t **sched, u_int8_t *key, int len)
  335 {
MALLOC(*sched, u_int8_t *, 384, M_CRYPTO_DATA, M_WAITOK);
bzero(*sched, 384);
  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) {
des3_zerokey(sched);
  342                 return -1;
  343         }
  345         return 0;
  346 }
  348 void
des3_zerokey(u_int8_t **sched)
  350 {
bzero(*sched, 384);
FREE(*sched, M_CRYPTO_DATA);
  353         *sched = NULL;
  354 }
  356 void
blf_encrypt(caddr_t key, u_int8_t *blk)
  358 {
blf_ecb_encrypt((blf_ctx *) key, blk, 8);
  360 }
  362 void
blf_decrypt(caddr_t key, u_int8_t *blk)
  364 {
blf_ecb_decrypt((blf_ctx *) key, blk, 8);
  366 }
  368 int
blf_setkey(u_int8_t **sched, u_int8_t *key, int len)
  370 {
MALLOC(*sched, u_int8_t *, sizeof(blf_ctx), M_CRYPTO_DATA, M_WAITOK);
bzero(*sched, sizeof(blf_ctx));
blf_key((blf_ctx *)*sched, key, len);
  375         return 0;
  376 }
  378 void
blf_zerokey(u_int8_t **sched)
  380 {
bzero(*sched, sizeof(blf_ctx));
FREE(*sched, M_CRYPTO_DATA);
  383         *sched = NULL;
  384 }
  386 int
null_setkey(u_int8_t **sched, u_int8_t *key, int len)
  388 {
  389         return 0;
  390 }
  392 void
null_zerokey(u_int8_t **sched)
  394 {
  395 }
  397 void
null_encrypt(caddr_t key, u_int8_t *blk)
  399 {
  400 }
  402 void
null_decrypt(caddr_t key, u_int8_t *blk)
  404 {
  405 }
  407 void
cast5_encrypt(caddr_t key, u_int8_t *blk)
  409 {
cast_encrypt((cast_key *) key, blk, blk);
  411 }
  413 void
cast5_decrypt(caddr_t key, u_int8_t *blk)
  415 {
cast_decrypt((cast_key *) key, blk, blk);
  417 }
  419 int
cast5_setkey(u_int8_t **sched, u_int8_t *key, int len)
  421 {
MALLOC(*sched, u_int8_t *, sizeof(cast_key), M_CRYPTO_DATA, M_WAITOK);
bzero(*sched, sizeof(cast_key));
cast_setkey((cast_key *)*sched, key, len);
  426         return 0;
  427 }
  429 void
cast5_zerokey(u_int8_t **sched)
  431 {
bzero(*sched, sizeof(cast_key));
FREE(*sched, M_CRYPTO_DATA);
  434         *sched = NULL;
  435 }
  437 void
skipjack_encrypt(caddr_t key, u_int8_t *blk)
  439 {
skipjack_forwards(blk, blk, (u_int8_t **) key);
  441 }
  443 void
skipjack_decrypt(caddr_t key, u_int8_t *blk)
  445 {
skipjack_backwards(blk, blk, (u_int8_t **) key);
  447 }
  449 int
skipjack_setkey(u_int8_t **sched, u_int8_t *key, int len)
  451 {
MALLOC(*sched, u_int8_t *, 10 * sizeof(u_int8_t *), M_CRYPTO_DATA,
M_WAITOK);
bzero(*sched, 10 * sizeof(u_int8_t *));
subkey_table_gen(key, (u_int8_t **) *sched);
  457         return 0;
  458 }
  460 void
skipjack_zerokey(u_int8_t **sched)
  462 {
  463         int k;
  465         for (k = 0; k < 10; k++) {
  466                 if (((u_int8_t **)(*sched))[k]) {
bzero(((u_int8_t **)(*sched))[k], 0x100);
FREE(((u_int8_t **)(*sched))[k], M_CRYPTO_DATA);
  469                 }
  470         }
bzero(*sched, 10 * sizeof(u_int8_t *));
FREE(*sched, M_CRYPTO_DATA);
  473         *sched = NULL;
  474 }
  476 void
rijndael128_encrypt(caddr_t key, u_int8_t *blk)
  478 {
rijndael_encrypt((rijndael_ctx *) key, (u_char *) blk, (u_char *) blk);
  480 }
  482 void
rijndael128_decrypt(caddr_t key, u_int8_t *blk)
  484 {
rijndael_decrypt((rijndael_ctx *) key, (u_char *) blk, (u_char *) blk);
  486 }
  488 int
rijndael128_setkey(u_int8_t **sched, u_int8_t *key, int len)
  490 {
MALLOC(*sched, u_int8_t *, sizeof(rijndael_ctx), M_CRYPTO_DATA,
M_WAITOK);
bzero(*sched, sizeof(rijndael_ctx));
  495         if (rijndael_set_key((rijndael_ctx *)*sched, (u_char *)key, len * 8)
  496             < 0) {
rijndael128_zerokey(sched);
  498                 return -1;
  499         }
  501         return 0;
  502 }
  504 void
rijndael128_zerokey(u_int8_t **sched)
  506 {
bzero(*sched, sizeof(rijndael_ctx));
FREE(*sched, M_CRYPTO_DATA);
  509         *sched = NULL;
  510 }
  512 #define AESCTR_NONCESIZE        4
  513 #define AESCTR_IVSIZE           8
  514 #define AESCTR_BLOCKSIZE        16
  516 struct aes_ctr_ctx {
u_int32_t       ac_ek[4*(AES_MAXROUNDS + 1)];
u_int8_t        ac_block[AESCTR_BLOCKSIZE];
  519         int             ac_nr;
  520 };
  522 void
aes_ctr_reinit(caddr_t key, u_int8_t *iv)
  524 {
  525         struct aes_ctr_ctx *ctx;
ctx = (struct aes_ctr_ctx *)key;
bcopy(iv, ctx->ac_block + AESCTR_NONCESIZE, AESCTR_IVSIZE);
  530         /* reset counter */
bzero(ctx->ac_block + AESCTR_NONCESIZE + AESCTR_IVSIZE, 4);
  532 }
  534 void
aes_ctr_crypt(caddr_t key, u_int8_t *data)
  536 {
  537         struct aes_ctr_ctx *ctx;
u_int8_t keystream[AESCTR_BLOCKSIZE];
  539         int i;
ctx = (struct aes_ctr_ctx *)key;
  542         /* increment counter */
  543         for (i = AESCTR_BLOCKSIZE - 1;
i >= AESCTR_NONCESIZE + AESCTR_IVSIZE; i--)
  545                 if (++ctx->ac_block[i])   /* continue on overflow */
  546                         break;
rijndaelEncrypt(ctx->ac_ek, ctx->ac_nr, ctx->ac_block, keystream);
  548         for (i = 0; i < AESCTR_BLOCKSIZE; i++)
data[i] ^= keystream[i];
  550 }
  552 int
aes_ctr_setkey(u_int8_t **sched, u_int8_t *key, int len)
  554 {
  555         struct aes_ctr_ctx *ctx;
  557         if (len < AESCTR_NONCESIZE)
  558                 return -1;
MALLOC(*sched, u_int8_t *, sizeof(struct aes_ctr_ctx), M_CRYPTO_DATA,
M_WAITOK);
bzero(*sched, sizeof(struct aes_ctr_ctx));
ctx = (struct aes_ctr_ctx *)*sched;
ctx->ac_nr = rijndaelKeySetupEnc(ctx->ac_ek, (u_char *)key,
  565             (len - AESCTR_NONCESIZE) * 8);
  566         if (ctx->ac_nr == 0) {
aes_ctr_zerokey(sched);
  568                 return -1;
  569         }
bcopy(key + len - AESCTR_NONCESIZE, ctx->ac_block, AESCTR_NONCESIZE);
  571         return 0;
  572 }
  574 void
aes_ctr_zerokey(u_int8_t **sched)
  576 {
bzero(*sched, sizeof(struct aes_ctr_ctx));
FREE(*sched, M_CRYPTO_DATA);
  579         *sched = NULL;
  580 }
  582 /*
  583  * And now for auth.
  584  */
  586 int
RMD160Update_int(void *ctx, u_int8_t *buf, u_int16_t len)
  588 {
RMD160Update(ctx, buf, len);
  590         return 0;
  591 }
  593 int
MD5Update_int(void *ctx, u_int8_t *buf, u_int16_t len)
  595 {
MD5Update(ctx, buf, len);
  597         return 0;
  598 }
  600 int
SHA1Update_int(void *ctx, u_int8_t *buf, u_int16_t len)
  602 {
SHA1Update(ctx, buf, len);
  604         return 0;
  605 }
  607 int
SHA256_Update_int(void *ctx, u_int8_t *buf, u_int16_t len)
  609 {
SHA256_Update(ctx, buf, len);
  611         return 0;
  612 }
  614 int
SHA384_Update_int(void *ctx, u_int8_t *buf, u_int16_t len)
  616 {
SHA384_Update(ctx, buf, len);
  618         return 0;
  619 }
  621 int
SHA512_Update_int(void *ctx, u_int8_t *buf, u_int16_t len)
  623 {
SHA512_Update(ctx, buf, len);
  625         return 0;
  626 }
  628 /*
  629  * And compression
  630  */
u_int32_t
deflate_compress(u_int8_t *data, u_int32_t size, u_int8_t **out)
  634 {
  635         return deflate_global(data, size, 0, out);
  636 }
u_int32_t
deflate_decompress(u_int8_t *data, u_int32_t size, u_int8_t **out)
  640 {
  641         return deflate_global(data, size, 1, out);
  642 }
u_int32_t
lzs_dummy(u_int8_t *data, u_int32_t size, u_int8_t **out)
  646 {
  647         *out = NULL;
  648         return (0);
  649 }