Home | History | Annotate | Line # | Download | only in opencrypto
cryptosoft.c revision 1.40.2.1
      1  1.40.2.1       tls /*	$NetBSD: cryptosoft.c,v 1.40.2.1 2013/02/25 00:30:07 tls Exp $ */
      2       1.1  jonathan /*	$FreeBSD: src/sys/opencrypto/cryptosoft.c,v 1.2.2.1 2002/11/21 23:34:23 sam Exp $	*/
      3       1.1  jonathan /*	$OpenBSD: cryptosoft.c,v 1.35 2002/04/26 08:43:50 deraadt Exp $	*/
      4       1.1  jonathan 
      5       1.1  jonathan /*
      6       1.1  jonathan  * The author of this code is Angelos D. Keromytis (angelos (at) cis.upenn.edu)
      7       1.1  jonathan  *
      8       1.1  jonathan  * This code was written by Angelos D. Keromytis in Athens, Greece, in
      9       1.1  jonathan  * February 2000. Network Security Technologies Inc. (NSTI) kindly
     10       1.1  jonathan  * supported the development of this code.
     11       1.1  jonathan  *
     12       1.1  jonathan  * Copyright (c) 2000, 2001 Angelos D. Keromytis
     13       1.1  jonathan  *
     14       1.1  jonathan  * Permission to use, copy, and modify this software with or without fee
     15       1.1  jonathan  * is hereby granted, provided that this entire notice is included in
     16       1.1  jonathan  * all source code copies of any software which is or includes a copy or
     17       1.1  jonathan  * modification of this software.
     18       1.1  jonathan  *
     19       1.1  jonathan  * THIS SOFTWARE IS BEING PROVIDED "AS IS", WITHOUT ANY EXPRESS OR
     20       1.1  jonathan  * IMPLIED WARRANTY. IN PARTICULAR, NONE OF THE AUTHORS MAKES ANY
     21       1.1  jonathan  * REPRESENTATION OR WARRANTY OF ANY KIND CONCERNING THE
     22       1.1  jonathan  * MERCHANTABILITY OF THIS SOFTWARE OR ITS FITNESS FOR ANY PARTICULAR
     23       1.1  jonathan  * PURPOSE.
     24       1.1  jonathan  */
     25       1.1  jonathan 
     26       1.1  jonathan #include <sys/cdefs.h>
     27  1.40.2.1       tls __KERNEL_RCSID(0, "$NetBSD: cryptosoft.c,v 1.40.2.1 2013/02/25 00:30:07 tls Exp $");
     28       1.1  jonathan 
     29       1.1  jonathan #include <sys/param.h>
     30       1.1  jonathan #include <sys/systm.h>
     31       1.1  jonathan #include <sys/malloc.h>
     32       1.1  jonathan #include <sys/mbuf.h>
     33       1.1  jonathan #include <sys/sysctl.h>
     34       1.1  jonathan #include <sys/errno.h>
     35  1.40.2.1       tls #include <sys/cprng.h>
     36       1.5  jonathan 
     37      1.20       tls #include "opt_ocf.h"
     38       1.1  jonathan #include <opencrypto/cryptodev.h>
     39       1.1  jonathan #include <opencrypto/cryptosoft.h>
     40       1.1  jonathan #include <opencrypto/xform.h>
     41       1.1  jonathan 
     42      1.10   thorpej #include <opencrypto/cryptosoft_xform.c>
     43       1.1  jonathan 
     44      1.10   thorpej union authctx {
     45      1.10   thorpej 	MD5_CTX md5ctx;
     46      1.10   thorpej 	SHA1_CTX sha1ctx;
     47      1.10   thorpej 	RMD160_CTX rmd160ctx;
     48      1.10   thorpej 	SHA256_CTX sha256ctx;
     49      1.10   thorpej 	SHA384_CTX sha384ctx;
     50      1.10   thorpej 	SHA512_CTX sha512ctx;
     51      1.36  drochner 	aesxcbc_ctx aesxcbcctx;
     52      1.37  drochner 	AES_GMAC_CTX aesgmacctx;
     53       1.1  jonathan };
     54       1.1  jonathan 
     55       1.1  jonathan struct swcr_data **swcr_sessions = NULL;
     56       1.1  jonathan u_int32_t swcr_sesnum = 0;
     57       1.1  jonathan int32_t swcr_id = -1;
     58       1.1  jonathan 
     59       1.1  jonathan #define COPYBACK(x, a, b, c, d) \
     60       1.1  jonathan 	(x) == CRYPTO_BUF_MBUF ? m_copyback((struct mbuf *)a,b,c,d) \
     61       1.1  jonathan 	: cuio_copyback((struct uio *)a,b,c,d)
     62       1.1  jonathan #define COPYDATA(x, a, b, c, d) \
     63       1.1  jonathan 	(x) == CRYPTO_BUF_MBUF ? m_copydata((struct mbuf *)a,b,c,d) \
     64       1.1  jonathan 	: cuio_copydata((struct uio *)a,b,c,d)
     65       1.1  jonathan 
     66      1.27  drochner static	int swcr_encdec(struct cryptodesc *, const struct swcr_data *, void *, int);
     67      1.27  drochner static	int swcr_compdec(struct cryptodesc *, const struct swcr_data *, void *, int, int *);
     68      1.37  drochner static	int swcr_combined(struct cryptop *, int);
     69       1.1  jonathan static	int swcr_process(void *, struct cryptop *, int);
     70       1.1  jonathan static	int swcr_newsession(void *, u_int32_t *, struct cryptoini *);
     71       1.1  jonathan static	int swcr_freesession(void *, u_int64_t);
     72       1.1  jonathan 
     73       1.1  jonathan /*
     74       1.1  jonathan  * Apply a symmetric encryption/decryption algorithm.
     75       1.1  jonathan  */
     76       1.1  jonathan static int
     77      1.27  drochner swcr_encdec(struct cryptodesc *crd, const struct swcr_data *sw, void *bufv,
     78       1.1  jonathan     int outtype)
     79       1.1  jonathan {
     80      1.17  christos 	char *buf = bufv;
     81       1.1  jonathan 	unsigned char iv[EALG_MAX_BLOCK_LEN], blk[EALG_MAX_BLOCK_LEN], *idat;
     82       1.1  jonathan 	unsigned char *ivp, piv[EALG_MAX_BLOCK_LEN];
     83      1.10   thorpej 	const struct swcr_enc_xform *exf;
     84      1.32  drochner 	int i, k, j, blks, ivlen;
     85       1.1  jonathan 	int count, ind;
     86       1.1  jonathan 
     87       1.1  jonathan 	exf = sw->sw_exf;
     88      1.10   thorpej 	blks = exf->enc_xform->blocksize;
     89      1.32  drochner 	ivlen = exf->enc_xform->ivsize;
     90      1.32  drochner 	KASSERT(exf->reinit ? ivlen <= blks : ivlen == blks);
     91       1.1  jonathan 
     92       1.1  jonathan 	/* Check for non-padded data */
     93       1.1  jonathan 	if (crd->crd_len % blks)
     94       1.1  jonathan 		return EINVAL;
     95       1.1  jonathan 
     96       1.1  jonathan 	/* Initialize the IV */
     97       1.1  jonathan 	if (crd->crd_flags & CRD_F_ENCRYPT) {
     98       1.1  jonathan 		/* IV explicitly provided ? */
     99      1.34  drochner 		if (crd->crd_flags & CRD_F_IV_EXPLICIT) {
    100      1.32  drochner 			memcpy(iv, crd->crd_iv, ivlen);
    101      1.34  drochner 			if (exf->reinit)
    102      1.34  drochner 				exf->reinit(sw->sw_kschedule, iv, 0);
    103      1.34  drochner 		} else if (exf->reinit) {
    104      1.34  drochner 			exf->reinit(sw->sw_kschedule, 0, iv);
    105      1.34  drochner 		} else {
    106       1.1  jonathan 			/* Get random IV */
    107       1.1  jonathan 			for (i = 0;
    108      1.31  drochner 			    i + sizeof (u_int32_t) <= EALG_MAX_BLOCK_LEN;
    109       1.1  jonathan 			    i += sizeof (u_int32_t)) {
    110      1.39       tls 				u_int32_t temp = cprng_fast32();
    111       1.1  jonathan 
    112      1.25   tsutsui 				memcpy(iv + i, &temp, sizeof(u_int32_t));
    113       1.1  jonathan 			}
    114       1.1  jonathan 			/*
    115       1.1  jonathan 			 * What if the block size is not a multiple
    116       1.1  jonathan 			 * of sizeof (u_int32_t), which is the size of
    117       1.1  jonathan 			 * what arc4random() returns ?
    118       1.1  jonathan 			 */
    119       1.1  jonathan 			if (EALG_MAX_BLOCK_LEN % sizeof (u_int32_t) != 0) {
    120      1.39       tls 				u_int32_t temp = cprng_fast32();
    121       1.1  jonathan 
    122       1.1  jonathan 				bcopy (&temp, iv + i,
    123       1.1  jonathan 				    EALG_MAX_BLOCK_LEN - i);
    124       1.1  jonathan 			}
    125       1.1  jonathan 		}
    126       1.1  jonathan 
    127       1.1  jonathan 		/* Do we need to write the IV */
    128       1.1  jonathan 		if (!(crd->crd_flags & CRD_F_IV_PRESENT)) {
    129      1.32  drochner 			COPYBACK(outtype, buf, crd->crd_inject, ivlen, iv);
    130       1.1  jonathan 		}
    131       1.1  jonathan 
    132       1.1  jonathan 	} else {	/* Decryption */
    133       1.1  jonathan 			/* IV explicitly provided ? */
    134       1.1  jonathan 		if (crd->crd_flags & CRD_F_IV_EXPLICIT)
    135      1.32  drochner 			memcpy(iv, crd->crd_iv, ivlen);
    136       1.1  jonathan 		else {
    137       1.1  jonathan 			/* Get IV off buf */
    138      1.32  drochner 			COPYDATA(outtype, buf, crd->crd_inject, ivlen, iv);
    139       1.1  jonathan 		}
    140      1.34  drochner 		if (exf->reinit)
    141      1.34  drochner 			exf->reinit(sw->sw_kschedule, iv, 0);
    142       1.1  jonathan 	}
    143       1.1  jonathan 
    144       1.1  jonathan 	ivp = iv;
    145       1.1  jonathan 
    146       1.1  jonathan 	if (outtype == CRYPTO_BUF_CONTIG) {
    147      1.32  drochner 		if (exf->reinit) {
    148      1.32  drochner 			for (i = crd->crd_skip;
    149      1.32  drochner 			     i < crd->crd_skip + crd->crd_len; i += blks) {
    150      1.32  drochner 				if (crd->crd_flags & CRD_F_ENCRYPT) {
    151      1.32  drochner 					exf->encrypt(sw->sw_kschedule, buf + i);
    152      1.32  drochner 				} else {
    153      1.32  drochner 					exf->decrypt(sw->sw_kschedule, buf + i);
    154      1.32  drochner 				}
    155      1.32  drochner 			}
    156      1.32  drochner 		} else if (crd->crd_flags & CRD_F_ENCRYPT) {
    157       1.1  jonathan 			for (i = crd->crd_skip;
    158       1.1  jonathan 			    i < crd->crd_skip + crd->crd_len; i += blks) {
    159       1.1  jonathan 				/* XOR with the IV/previous block, as appropriate. */
    160       1.1  jonathan 				if (i == crd->crd_skip)
    161       1.1  jonathan 					for (k = 0; k < blks; k++)
    162       1.1  jonathan 						buf[i + k] ^= ivp[k];
    163       1.1  jonathan 				else
    164       1.1  jonathan 					for (k = 0; k < blks; k++)
    165       1.1  jonathan 						buf[i + k] ^= buf[i + k - blks];
    166       1.1  jonathan 				exf->encrypt(sw->sw_kschedule, buf + i);
    167       1.1  jonathan 			}
    168       1.1  jonathan 		} else {		/* Decrypt */
    169       1.1  jonathan 			/*
    170       1.1  jonathan 			 * Start at the end, so we don't need to keep the encrypted
    171       1.1  jonathan 			 * block as the IV for the next block.
    172       1.1  jonathan 			 */
    173       1.1  jonathan 			for (i = crd->crd_skip + crd->crd_len - blks;
    174       1.1  jonathan 			    i >= crd->crd_skip; i -= blks) {
    175       1.1  jonathan 				exf->decrypt(sw->sw_kschedule, buf + i);
    176       1.1  jonathan 
    177       1.1  jonathan 				/* XOR with the IV/previous block, as appropriate */
    178       1.1  jonathan 				if (i == crd->crd_skip)
    179       1.1  jonathan 					for (k = 0; k < blks; k++)
    180       1.1  jonathan 						buf[i + k] ^= ivp[k];
    181       1.1  jonathan 				else
    182       1.1  jonathan 					for (k = 0; k < blks; k++)
    183       1.1  jonathan 						buf[i + k] ^= buf[i + k - blks];
    184       1.1  jonathan 			}
    185       1.1  jonathan 		}
    186       1.1  jonathan 
    187       1.1  jonathan 		return 0;
    188       1.1  jonathan 	} else if (outtype == CRYPTO_BUF_MBUF) {
    189       1.1  jonathan 		struct mbuf *m = (struct mbuf *) buf;
    190       1.1  jonathan 
    191       1.1  jonathan 		/* Find beginning of data */
    192       1.1  jonathan 		m = m_getptr(m, crd->crd_skip, &k);
    193       1.1  jonathan 		if (m == NULL)
    194       1.1  jonathan 			return EINVAL;
    195       1.1  jonathan 
    196       1.1  jonathan 		i = crd->crd_len;
    197       1.1  jonathan 
    198       1.1  jonathan 		while (i > 0) {
    199       1.1  jonathan 			/*
    200       1.1  jonathan 			 * If there's insufficient data at the end of
    201       1.1  jonathan 			 * an mbuf, we have to do some copying.
    202       1.1  jonathan 			 */
    203       1.1  jonathan 			if (m->m_len < k + blks && m->m_len != k) {
    204       1.1  jonathan 				m_copydata(m, k, blks, blk);
    205       1.1  jonathan 
    206       1.1  jonathan 				/* Actual encryption/decryption */
    207      1.32  drochner 				if (exf->reinit) {
    208      1.32  drochner 					if (crd->crd_flags & CRD_F_ENCRYPT) {
    209      1.32  drochner 						exf->encrypt(sw->sw_kschedule,
    210      1.32  drochner 							     blk);
    211      1.32  drochner 					} else {
    212      1.32  drochner 						exf->decrypt(sw->sw_kschedule,
    213      1.32  drochner 							     blk);
    214      1.32  drochner 					}
    215      1.32  drochner 				} else if (crd->crd_flags & CRD_F_ENCRYPT) {
    216       1.1  jonathan 					/* XOR with previous block */
    217       1.1  jonathan 					for (j = 0; j < blks; j++)
    218       1.1  jonathan 						blk[j] ^= ivp[j];
    219       1.1  jonathan 
    220       1.1  jonathan 					exf->encrypt(sw->sw_kschedule, blk);
    221       1.1  jonathan 
    222       1.1  jonathan 					/*
    223       1.1  jonathan 					 * Keep encrypted block for XOR'ing
    224       1.1  jonathan 					 * with next block
    225       1.1  jonathan 					 */
    226      1.25   tsutsui 					memcpy(iv, blk, blks);
    227       1.1  jonathan 					ivp = iv;
    228       1.1  jonathan 				} else {	/* decrypt */
    229       1.1  jonathan 					/*
    230       1.1  jonathan 					 * Keep encrypted block for XOR'ing
    231       1.1  jonathan 					 * with next block
    232       1.1  jonathan 					 */
    233       1.1  jonathan 					if (ivp == iv)
    234      1.25   tsutsui 						memcpy(piv, blk, blks);
    235       1.1  jonathan 					else
    236      1.25   tsutsui 						memcpy(iv, blk, blks);
    237       1.1  jonathan 
    238       1.1  jonathan 					exf->decrypt(sw->sw_kschedule, blk);
    239       1.1  jonathan 
    240       1.1  jonathan 					/* XOR with previous block */
    241       1.1  jonathan 					for (j = 0; j < blks; j++)
    242       1.1  jonathan 						blk[j] ^= ivp[j];
    243       1.1  jonathan 
    244       1.1  jonathan 					if (ivp == iv)
    245      1.25   tsutsui 						memcpy(iv, piv, blks);
    246       1.1  jonathan 					else
    247       1.1  jonathan 						ivp = iv;
    248       1.1  jonathan 				}
    249       1.1  jonathan 
    250       1.1  jonathan 				/* Copy back decrypted block */
    251       1.1  jonathan 				m_copyback(m, k, blks, blk);
    252       1.1  jonathan 
    253       1.1  jonathan 				/* Advance pointer */
    254       1.1  jonathan 				m = m_getptr(m, k + blks, &k);
    255       1.1  jonathan 				if (m == NULL)
    256       1.1  jonathan 					return EINVAL;
    257       1.1  jonathan 
    258       1.1  jonathan 				i -= blks;
    259       1.1  jonathan 
    260       1.1  jonathan 				/* Could be done... */
    261       1.1  jonathan 				if (i == 0)
    262       1.1  jonathan 					break;
    263       1.1  jonathan 			}
    264       1.1  jonathan 
    265       1.1  jonathan 			/* Skip possibly empty mbufs */
    266       1.1  jonathan 			if (k == m->m_len) {
    267       1.1  jonathan 				for (m = m->m_next; m && m->m_len == 0;
    268       1.1  jonathan 				    m = m->m_next)
    269       1.1  jonathan 					;
    270       1.1  jonathan 				k = 0;
    271       1.1  jonathan 			}
    272       1.1  jonathan 
    273       1.1  jonathan 			/* Sanity check */
    274       1.1  jonathan 			if (m == NULL)
    275       1.1  jonathan 				return EINVAL;
    276       1.1  jonathan 
    277       1.1  jonathan 			/*
    278       1.1  jonathan 			 * Warning: idat may point to garbage here, but
    279       1.1  jonathan 			 * we only use it in the while() loop, only if
    280       1.1  jonathan 			 * there are indeed enough data.
    281       1.1  jonathan 			 */
    282       1.1  jonathan 			idat = mtod(m, unsigned char *) + k;
    283       1.1  jonathan 
    284       1.1  jonathan 			while (m->m_len >= k + blks && i > 0) {
    285      1.32  drochner 				if (exf->reinit) {
    286      1.32  drochner 					if (crd->crd_flags & CRD_F_ENCRYPT) {
    287      1.32  drochner 						exf->encrypt(sw->sw_kschedule,
    288      1.32  drochner 							     idat);
    289      1.32  drochner 					} else {
    290      1.32  drochner 						exf->decrypt(sw->sw_kschedule,
    291      1.32  drochner 							     idat);
    292      1.32  drochner 					}
    293      1.32  drochner 				} else if (crd->crd_flags & CRD_F_ENCRYPT) {
    294       1.1  jonathan 					/* XOR with previous block/IV */
    295       1.1  jonathan 					for (j = 0; j < blks; j++)
    296       1.1  jonathan 						idat[j] ^= ivp[j];
    297       1.1  jonathan 
    298       1.1  jonathan 					exf->encrypt(sw->sw_kschedule, idat);
    299       1.1  jonathan 					ivp = idat;
    300       1.1  jonathan 				} else {	/* decrypt */
    301       1.1  jonathan 					/*
    302       1.1  jonathan 					 * Keep encrypted block to be used
    303       1.1  jonathan 					 * in next block's processing.
    304       1.1  jonathan 					 */
    305       1.1  jonathan 					if (ivp == iv)
    306      1.25   tsutsui 						memcpy(piv, idat, blks);
    307       1.1  jonathan 					else
    308      1.25   tsutsui 						memcpy(iv, idat, blks);
    309       1.1  jonathan 
    310       1.1  jonathan 					exf->decrypt(sw->sw_kschedule, idat);
    311       1.1  jonathan 
    312       1.1  jonathan 					/* XOR with previous block/IV */
    313       1.1  jonathan 					for (j = 0; j < blks; j++)
    314       1.1  jonathan 						idat[j] ^= ivp[j];
    315       1.1  jonathan 
    316       1.1  jonathan 					if (ivp == iv)
    317      1.25   tsutsui 						memcpy(iv, piv, blks);
    318       1.1  jonathan 					else
    319       1.1  jonathan 						ivp = iv;
    320       1.1  jonathan 				}
    321       1.1  jonathan 
    322       1.1  jonathan 				idat += blks;
    323       1.1  jonathan 				k += blks;
    324       1.1  jonathan 				i -= blks;
    325       1.1  jonathan 			}
    326       1.1  jonathan 		}
    327       1.1  jonathan 
    328       1.1  jonathan 		return 0; /* Done with mbuf encryption/decryption */
    329       1.1  jonathan 	} else if (outtype == CRYPTO_BUF_IOV) {
    330       1.1  jonathan 		struct uio *uio = (struct uio *) buf;
    331       1.1  jonathan 
    332       1.1  jonathan 		/* Find beginning of data */
    333       1.1  jonathan 		count = crd->crd_skip;
    334       1.1  jonathan 		ind = cuio_getptr(uio, count, &k);
    335       1.1  jonathan 		if (ind == -1)
    336       1.1  jonathan 			return EINVAL;
    337       1.1  jonathan 
    338       1.1  jonathan 		i = crd->crd_len;
    339       1.1  jonathan 
    340       1.1  jonathan 		while (i > 0) {
    341       1.1  jonathan 			/*
    342       1.1  jonathan 			 * If there's insufficient data at the end,
    343       1.1  jonathan 			 * we have to do some copying.
    344       1.1  jonathan 			 */
    345       1.1  jonathan 			if (uio->uio_iov[ind].iov_len < k + blks &&
    346       1.1  jonathan 			    uio->uio_iov[ind].iov_len != k) {
    347       1.1  jonathan 				cuio_copydata(uio, k, blks, blk);
    348       1.1  jonathan 
    349       1.1  jonathan 				/* Actual encryption/decryption */
    350      1.32  drochner 				if (exf->reinit) {
    351      1.32  drochner 					if (crd->crd_flags & CRD_F_ENCRYPT) {
    352      1.32  drochner 						exf->encrypt(sw->sw_kschedule,
    353      1.32  drochner 							     blk);
    354      1.32  drochner 					} else {
    355      1.32  drochner 						exf->decrypt(sw->sw_kschedule,
    356      1.32  drochner 							     blk);
    357      1.32  drochner 					}
    358      1.32  drochner 				} else if (crd->crd_flags & CRD_F_ENCRYPT) {
    359       1.1  jonathan 					/* XOR with previous block */
    360       1.1  jonathan 					for (j = 0; j < blks; j++)
    361       1.1  jonathan 						blk[j] ^= ivp[j];
    362       1.1  jonathan 
    363       1.1  jonathan 					exf->encrypt(sw->sw_kschedule, blk);
    364       1.1  jonathan 
    365       1.1  jonathan 					/*
    366       1.1  jonathan 					 * Keep encrypted block for XOR'ing
    367       1.1  jonathan 					 * with next block
    368       1.1  jonathan 					 */
    369      1.25   tsutsui 					memcpy(iv, blk, blks);
    370       1.1  jonathan 					ivp = iv;
    371       1.1  jonathan 				} else {	/* decrypt */
    372       1.1  jonathan 					/*
    373       1.1  jonathan 					 * Keep encrypted block for XOR'ing
    374       1.1  jonathan 					 * with next block
    375       1.1  jonathan 					 */
    376       1.1  jonathan 					if (ivp == iv)
    377      1.25   tsutsui 						memcpy(piv, blk, blks);
    378       1.1  jonathan 					else
    379      1.25   tsutsui 						memcpy(iv, blk, blks);
    380       1.1  jonathan 
    381       1.1  jonathan 					exf->decrypt(sw->sw_kschedule, blk);
    382       1.1  jonathan 
    383       1.1  jonathan 					/* XOR with previous block */
    384       1.1  jonathan 					for (j = 0; j < blks; j++)
    385       1.1  jonathan 						blk[j] ^= ivp[j];
    386       1.1  jonathan 
    387       1.1  jonathan 					if (ivp == iv)
    388      1.25   tsutsui 						memcpy(iv, piv, blks);
    389       1.1  jonathan 					else
    390       1.1  jonathan 						ivp = iv;
    391       1.1  jonathan 				}
    392       1.1  jonathan 
    393       1.1  jonathan 				/* Copy back decrypted block */
    394       1.1  jonathan 				cuio_copyback(uio, k, blks, blk);
    395       1.1  jonathan 
    396       1.1  jonathan 				count += blks;
    397       1.1  jonathan 
    398       1.1  jonathan 				/* Advance pointer */
    399       1.1  jonathan 				ind = cuio_getptr(uio, count, &k);
    400       1.1  jonathan 				if (ind == -1)
    401       1.1  jonathan 					return (EINVAL);
    402       1.1  jonathan 
    403       1.1  jonathan 				i -= blks;
    404       1.1  jonathan 
    405       1.1  jonathan 				/* Could be done... */
    406       1.1  jonathan 				if (i == 0)
    407       1.1  jonathan 					break;
    408       1.1  jonathan 			}
    409       1.1  jonathan 
    410       1.1  jonathan 			/*
    411       1.1  jonathan 			 * Warning: idat may point to garbage here, but
    412       1.1  jonathan 			 * we only use it in the while() loop, only if
    413       1.1  jonathan 			 * there are indeed enough data.
    414       1.1  jonathan 			 */
    415      1.17  christos 			idat = ((char *)uio->uio_iov[ind].iov_base) + k;
    416       1.1  jonathan 
    417       1.1  jonathan 			while (uio->uio_iov[ind].iov_len >= k + blks &&
    418       1.1  jonathan 			    i > 0) {
    419      1.32  drochner 				if (exf->reinit) {
    420      1.32  drochner 					if (crd->crd_flags & CRD_F_ENCRYPT) {
    421      1.32  drochner 						exf->encrypt(sw->sw_kschedule,
    422      1.32  drochner 							    idat);
    423      1.32  drochner 					} else {
    424      1.32  drochner 						exf->decrypt(sw->sw_kschedule,
    425      1.32  drochner 							    idat);
    426      1.32  drochner 					}
    427      1.32  drochner 				} else if (crd->crd_flags & CRD_F_ENCRYPT) {
    428       1.1  jonathan 					/* XOR with previous block/IV */
    429       1.1  jonathan 					for (j = 0; j < blks; j++)
    430       1.1  jonathan 						idat[j] ^= ivp[j];
    431       1.1  jonathan 
    432       1.1  jonathan 					exf->encrypt(sw->sw_kschedule, idat);
    433       1.1  jonathan 					ivp = idat;
    434       1.1  jonathan 				} else {	/* decrypt */
    435       1.1  jonathan 					/*
    436       1.1  jonathan 					 * Keep encrypted block to be used
    437       1.1  jonathan 					 * in next block's processing.
    438       1.1  jonathan 					 */
    439       1.1  jonathan 					if (ivp == iv)
    440      1.25   tsutsui 						memcpy(piv, idat, blks);
    441       1.1  jonathan 					else
    442      1.25   tsutsui 						memcpy(iv, idat, blks);
    443       1.1  jonathan 
    444       1.1  jonathan 					exf->decrypt(sw->sw_kschedule, idat);
    445       1.1  jonathan 
    446       1.1  jonathan 					/* XOR with previous block/IV */
    447       1.1  jonathan 					for (j = 0; j < blks; j++)
    448       1.1  jonathan 						idat[j] ^= ivp[j];
    449       1.1  jonathan 
    450       1.1  jonathan 					if (ivp == iv)
    451      1.25   tsutsui 						memcpy(iv, piv, blks);
    452       1.1  jonathan 					else
    453       1.1  jonathan 						ivp = iv;
    454       1.1  jonathan 				}
    455       1.1  jonathan 
    456       1.1  jonathan 				idat += blks;
    457       1.1  jonathan 				count += blks;
    458       1.1  jonathan 				k += blks;
    459       1.1  jonathan 				i -= blks;
    460       1.1  jonathan 			}
    461       1.1  jonathan 		}
    462       1.1  jonathan 		return 0; /* Done with mbuf encryption/decryption */
    463       1.1  jonathan 	}
    464       1.1  jonathan 
    465       1.1  jonathan 	/* Unreachable */
    466       1.1  jonathan 	return EINVAL;
    467       1.1  jonathan }
    468       1.1  jonathan 
    469       1.1  jonathan /*
    470       1.1  jonathan  * Compute keyed-hash authenticator.
    471       1.1  jonathan  */
    472      1.16    daniel int
    473       1.1  jonathan swcr_authcompute(struct cryptop *crp, struct cryptodesc *crd,
    474      1.27  drochner     const struct swcr_data *sw, void *buf, int outtype)
    475       1.1  jonathan {
    476       1.1  jonathan 	unsigned char aalg[AALG_MAX_RESULT_LEN];
    477      1.10   thorpej 	const struct swcr_auth_hash *axf;
    478       1.1  jonathan 	union authctx ctx;
    479       1.1  jonathan 	int err;
    480       1.1  jonathan 
    481       1.1  jonathan 	if (sw->sw_ictx == 0)
    482       1.1  jonathan 		return EINVAL;
    483       1.1  jonathan 
    484       1.1  jonathan 	axf = sw->sw_axf;
    485       1.1  jonathan 
    486      1.35  drochner 	memcpy(&ctx, sw->sw_ictx, axf->ctxsize);
    487       1.1  jonathan 
    488       1.1  jonathan 	switch (outtype) {
    489       1.1  jonathan 	case CRYPTO_BUF_CONTIG:
    490      1.17  christos 		axf->Update(&ctx, (char *)buf + crd->crd_skip, crd->crd_len);
    491       1.1  jonathan 		break;
    492       1.1  jonathan 	case CRYPTO_BUF_MBUF:
    493       1.1  jonathan 		err = m_apply((struct mbuf *) buf, crd->crd_skip, crd->crd_len,
    494      1.17  christos 		    (int (*)(void*, void *, unsigned int)) axf->Update,
    495      1.17  christos 		    (void *) &ctx);
    496       1.1  jonathan 		if (err)
    497       1.1  jonathan 			return err;
    498       1.1  jonathan 		break;
    499       1.1  jonathan 	case CRYPTO_BUF_IOV:
    500       1.2  jonathan 		err = cuio_apply((struct uio *) buf, crd->crd_skip,
    501       1.2  jonathan 		    crd->crd_len,
    502      1.17  christos 		    (int (*)(void *, void *, unsigned int)) axf->Update,
    503      1.17  christos 		    (void *) &ctx);
    504       1.2  jonathan 		if (err) {
    505       1.2  jonathan 			return err;
    506       1.2  jonathan 		}
    507       1.2  jonathan 		break;
    508       1.1  jonathan 	default:
    509       1.1  jonathan 		return EINVAL;
    510       1.1  jonathan 	}
    511       1.1  jonathan 
    512       1.1  jonathan 	switch (sw->sw_alg) {
    513       1.1  jonathan 	case CRYPTO_MD5_HMAC:
    514      1.19       tls 	case CRYPTO_MD5_HMAC_96:
    515       1.1  jonathan 	case CRYPTO_SHA1_HMAC:
    516      1.19       tls 	case CRYPTO_SHA1_HMAC_96:
    517      1.29  drochner 	case CRYPTO_SHA2_256_HMAC:
    518      1.29  drochner 	case CRYPTO_SHA2_384_HMAC:
    519      1.29  drochner 	case CRYPTO_SHA2_512_HMAC:
    520       1.1  jonathan 	case CRYPTO_RIPEMD160_HMAC:
    521      1.19       tls 	case CRYPTO_RIPEMD160_HMAC_96:
    522       1.1  jonathan 		if (sw->sw_octx == NULL)
    523       1.1  jonathan 			return EINVAL;
    524       1.1  jonathan 
    525       1.1  jonathan 		axf->Final(aalg, &ctx);
    526      1.35  drochner 		memcpy(&ctx, sw->sw_octx, axf->ctxsize);
    527      1.10   thorpej 		axf->Update(&ctx, aalg, axf->auth_hash->hashsize);
    528       1.1  jonathan 		axf->Final(aalg, &ctx);
    529       1.1  jonathan 		break;
    530       1.1  jonathan 
    531       1.1  jonathan 	case CRYPTO_MD5_KPDK:
    532       1.1  jonathan 	case CRYPTO_SHA1_KPDK:
    533       1.1  jonathan 		if (sw->sw_octx == NULL)
    534       1.1  jonathan 			return EINVAL;
    535       1.1  jonathan 
    536       1.1  jonathan 		axf->Update(&ctx, sw->sw_octx, sw->sw_klen);
    537       1.1  jonathan 		axf->Final(aalg, &ctx);
    538       1.1  jonathan 		break;
    539       1.1  jonathan 
    540       1.1  jonathan 	case CRYPTO_NULL_HMAC:
    541       1.1  jonathan 	case CRYPTO_MD5:
    542       1.1  jonathan 	case CRYPTO_SHA1:
    543      1.36  drochner 	case CRYPTO_AES_XCBC_MAC_96:
    544       1.1  jonathan 		axf->Final(aalg, &ctx);
    545       1.1  jonathan 		break;
    546       1.1  jonathan 	}
    547       1.1  jonathan 
    548       1.1  jonathan 	/* Inject the authentication data */
    549       1.2  jonathan 	switch (outtype) {
    550       1.2  jonathan 	case CRYPTO_BUF_CONTIG:
    551      1.17  christos 		(void)memcpy((char *)buf + crd->crd_inject, aalg,
    552      1.17  christos 		    axf->auth_hash->authsize);
    553       1.2  jonathan 		break;
    554       1.2  jonathan 	case CRYPTO_BUF_MBUF:
    555       1.1  jonathan 		m_copyback((struct mbuf *) buf, crd->crd_inject,
    556      1.10   thorpej 		    axf->auth_hash->authsize, aalg);
    557       1.2  jonathan 		break;
    558       1.2  jonathan 	case CRYPTO_BUF_IOV:
    559      1.25   tsutsui 		memcpy(crp->crp_mac, aalg, axf->auth_hash->authsize);
    560       1.2  jonathan 		break;
    561       1.2  jonathan 	default:
    562       1.2  jonathan 		return EINVAL;
    563       1.2  jonathan 	}
    564       1.1  jonathan 	return 0;
    565       1.1  jonathan }
    566       1.1  jonathan 
    567       1.1  jonathan /*
    568      1.37  drochner  * Apply a combined encryption-authentication transformation
    569      1.37  drochner  */
    570      1.37  drochner static int
    571      1.37  drochner swcr_combined(struct cryptop *crp, int outtype)
    572      1.37  drochner {
    573      1.37  drochner 	uint32_t blkbuf[howmany(EALG_MAX_BLOCK_LEN, sizeof(uint32_t))];
    574      1.37  drochner 	u_char *blk = (u_char *)blkbuf;
    575      1.37  drochner 	u_char aalg[AALG_MAX_RESULT_LEN];
    576      1.37  drochner 	u_char iv[EALG_MAX_BLOCK_LEN];
    577      1.37  drochner 	union authctx ctx;
    578      1.37  drochner 	struct cryptodesc *crd, *crda = NULL, *crde = NULL;
    579      1.37  drochner 	struct swcr_data *sw, *swa, *swe = NULL;
    580      1.37  drochner 	const struct swcr_auth_hash *axf = NULL;
    581      1.37  drochner 	const struct swcr_enc_xform *exf = NULL;
    582      1.37  drochner 	void *buf = (void *)crp->crp_buf;
    583      1.37  drochner 	uint32_t *blkp;
    584      1.37  drochner 	int i, blksz = 0, ivlen = 0, len;
    585      1.37  drochner 
    586      1.37  drochner 	for (crd = crp->crp_desc; crd; crd = crd->crd_next) {
    587      1.37  drochner 		for (sw = swcr_sessions[crp->crp_sid & 0xffffffff];
    588      1.37  drochner 		     sw && sw->sw_alg != crd->crd_alg;
    589      1.37  drochner 		     sw = sw->sw_next)
    590      1.37  drochner 			;
    591      1.37  drochner 		if (sw == NULL)
    592      1.37  drochner 			return (EINVAL);
    593      1.37  drochner 
    594      1.37  drochner 		switch (sw->sw_alg) {
    595      1.37  drochner 		case CRYPTO_AES_GCM_16:
    596      1.37  drochner 		case CRYPTO_AES_GMAC:
    597      1.37  drochner 			swe = sw;
    598      1.37  drochner 			crde = crd;
    599      1.37  drochner 			exf = swe->sw_exf;
    600      1.37  drochner 			ivlen = exf->enc_xform->ivsize;
    601      1.37  drochner 			break;
    602      1.37  drochner 		case CRYPTO_AES_128_GMAC:
    603      1.37  drochner 		case CRYPTO_AES_192_GMAC:
    604      1.37  drochner 		case CRYPTO_AES_256_GMAC:
    605      1.37  drochner 			swa = sw;
    606      1.37  drochner 			crda = crd;
    607      1.37  drochner 			axf = swa->sw_axf;
    608      1.37  drochner 			if (swa->sw_ictx == 0)
    609      1.37  drochner 				return (EINVAL);
    610      1.37  drochner 			memcpy(&ctx, swa->sw_ictx, axf->ctxsize);
    611      1.37  drochner 			blksz = axf->auth_hash->blocksize;
    612      1.37  drochner 			break;
    613      1.37  drochner 		default:
    614      1.37  drochner 			return (EINVAL);
    615      1.37  drochner 		}
    616      1.37  drochner 	}
    617      1.37  drochner 	if (crde == NULL || crda == NULL)
    618      1.37  drochner 		return (EINVAL);
    619      1.37  drochner 	if (outtype == CRYPTO_BUF_CONTIG)
    620      1.37  drochner 		return (EINVAL);
    621      1.37  drochner 
    622      1.37  drochner 	/* Initialize the IV */
    623      1.37  drochner 	if (crde->crd_flags & CRD_F_ENCRYPT) {
    624      1.37  drochner 		/* IV explicitly provided ? */
    625      1.37  drochner 		if (crde->crd_flags & CRD_F_IV_EXPLICIT) {
    626      1.37  drochner 			memcpy(iv, crde->crd_iv, ivlen);
    627      1.37  drochner 			if (exf->reinit)
    628      1.37  drochner 				exf->reinit(swe->sw_kschedule, iv, 0);
    629      1.37  drochner 		} else if (exf->reinit)
    630      1.37  drochner 			exf->reinit(swe->sw_kschedule, 0, iv);
    631      1.37  drochner 		else
    632      1.39       tls 			cprng_fast(iv, ivlen);
    633      1.37  drochner 
    634      1.37  drochner 		/* Do we need to write the IV */
    635      1.37  drochner 		if (!(crde->crd_flags & CRD_F_IV_PRESENT))
    636      1.37  drochner 			COPYBACK(outtype, buf, crde->crd_inject, ivlen, iv);
    637      1.37  drochner 
    638      1.37  drochner 	} else {	/* Decryption */
    639      1.37  drochner 			/* IV explicitly provided ? */
    640      1.37  drochner 		if (crde->crd_flags & CRD_F_IV_EXPLICIT)
    641      1.37  drochner 			memcpy(iv, crde->crd_iv, ivlen);
    642      1.37  drochner 		else {
    643      1.37  drochner 			/* Get IV off buf */
    644      1.37  drochner 			COPYDATA(outtype, buf, crde->crd_inject, ivlen, iv);
    645      1.37  drochner 		}
    646      1.37  drochner 		if (exf->reinit)
    647      1.37  drochner 			exf->reinit(swe->sw_kschedule, iv, 0);
    648      1.37  drochner 	}
    649      1.37  drochner 
    650      1.37  drochner 	/* Supply MAC with IV */
    651      1.37  drochner 	if (axf->Reinit)
    652      1.37  drochner 		axf->Reinit(&ctx, iv, ivlen);
    653      1.37  drochner 
    654      1.37  drochner 	/* Supply MAC with AAD */
    655      1.37  drochner 	for (i = 0; i < crda->crd_len; i += blksz) {
    656      1.37  drochner 		len = MIN(crda->crd_len - i, blksz);
    657      1.37  drochner 		COPYDATA(outtype, buf, crda->crd_skip + i, len, blk);
    658      1.37  drochner 		axf->Update(&ctx, blk, len);
    659      1.37  drochner 	}
    660      1.37  drochner 
    661      1.37  drochner 	/* Do encryption/decryption with MAC */
    662      1.37  drochner 	for (i = 0; i < crde->crd_len; i += blksz) {
    663      1.37  drochner 		len = MIN(crde->crd_len - i, blksz);
    664      1.37  drochner 		if (len < blksz)
    665      1.37  drochner 			memset(blk, 0, blksz);
    666      1.37  drochner 		COPYDATA(outtype, buf, crde->crd_skip + i, len, blk);
    667      1.37  drochner 		if (crde->crd_flags & CRD_F_ENCRYPT) {
    668      1.37  drochner 			exf->encrypt(swe->sw_kschedule, blk);
    669      1.37  drochner 			axf->Update(&ctx, blk, len);
    670      1.37  drochner 		} else {
    671      1.37  drochner 			axf->Update(&ctx, blk, len);
    672      1.37  drochner 			exf->decrypt(swe->sw_kschedule, blk);
    673      1.37  drochner 		}
    674      1.37  drochner 		COPYBACK(outtype, buf, crde->crd_skip + i, len, blk);
    675      1.37  drochner 	}
    676      1.37  drochner 
    677      1.37  drochner 	/* Do any required special finalization */
    678      1.37  drochner 	switch (crda->crd_alg) {
    679      1.37  drochner 		case CRYPTO_AES_128_GMAC:
    680      1.37  drochner 		case CRYPTO_AES_192_GMAC:
    681      1.37  drochner 		case CRYPTO_AES_256_GMAC:
    682      1.37  drochner 			/* length block */
    683      1.37  drochner 			memset(blk, 0, blksz);
    684      1.37  drochner 			blkp = (uint32_t *)blk + 1;
    685      1.37  drochner 			*blkp = htobe32(crda->crd_len * 8);
    686      1.37  drochner 			blkp = (uint32_t *)blk + 3;
    687      1.37  drochner 			*blkp = htobe32(crde->crd_len * 8);
    688      1.37  drochner 			axf->Update(&ctx, blk, blksz);
    689      1.37  drochner 			break;
    690      1.37  drochner 	}
    691      1.37  drochner 
    692      1.37  drochner 	/* Finalize MAC */
    693      1.37  drochner 	axf->Final(aalg, &ctx);
    694      1.37  drochner 
    695      1.37  drochner 	/* Inject the authentication data */
    696      1.37  drochner 	if (outtype == CRYPTO_BUF_MBUF)
    697      1.37  drochner 		COPYBACK(outtype, buf, crda->crd_inject, axf->auth_hash->authsize, aalg);
    698      1.37  drochner 	else
    699      1.37  drochner 		memcpy(crp->crp_mac, aalg, axf->auth_hash->authsize);
    700      1.37  drochner 
    701      1.37  drochner 	return (0);
    702      1.37  drochner }
    703      1.37  drochner 
    704      1.37  drochner /*
    705       1.1  jonathan  * Apply a compression/decompression algorithm
    706       1.1  jonathan  */
    707       1.1  jonathan static int
    708      1.27  drochner swcr_compdec(struct cryptodesc *crd, const struct swcr_data *sw,
    709      1.27  drochner     void *buf, int outtype, int *res_size)
    710       1.1  jonathan {
    711       1.1  jonathan 	u_int8_t *data, *out;
    712      1.10   thorpej 	const struct swcr_comp_algo *cxf;
    713       1.1  jonathan 	int adj;
    714       1.1  jonathan 	u_int32_t result;
    715       1.1  jonathan 
    716       1.1  jonathan 	cxf = sw->sw_cxf;
    717       1.1  jonathan 
    718       1.1  jonathan 	/* We must handle the whole buffer of data in one time
    719       1.1  jonathan 	 * then if there is not all the data in the mbuf, we must
    720       1.1  jonathan 	 * copy in a buffer.
    721       1.1  jonathan 	 */
    722       1.1  jonathan 
    723      1.12  christos 	data = malloc(crd->crd_len, M_CRYPTO_DATA, M_NOWAIT);
    724       1.1  jonathan 	if (data == NULL)
    725       1.1  jonathan 		return (EINVAL);
    726       1.1  jonathan 	COPYDATA(outtype, buf, crd->crd_skip, crd->crd_len, data);
    727       1.1  jonathan 
    728       1.1  jonathan 	if (crd->crd_flags & CRD_F_COMP)
    729       1.1  jonathan 		result = cxf->compress(data, crd->crd_len, &out);
    730       1.1  jonathan 	else
    731      1.28  drochner 		result = cxf->decompress(data, crd->crd_len, &out,
    732      1.28  drochner 					 *res_size);
    733       1.1  jonathan 
    734      1.21    cegger 	free(data, M_CRYPTO_DATA);
    735       1.1  jonathan 	if (result == 0)
    736       1.1  jonathan 		return EINVAL;
    737       1.1  jonathan 
    738       1.1  jonathan 	/* Copy back the (de)compressed data. m_copyback is
    739       1.1  jonathan 	 * extending the mbuf as necessary.
    740       1.1  jonathan 	 */
    741      1.27  drochner 	*res_size = (int)result;
    742       1.1  jonathan 	/* Check the compressed size when doing compression */
    743      1.28  drochner 	if (crd->crd_flags & CRD_F_COMP &&
    744      1.28  drochner 	    sw->sw_alg == CRYPTO_DEFLATE_COMP_NOGROW &&
    745      1.28  drochner 	    result >= crd->crd_len) {
    746       1.1  jonathan 			/* Compression was useless, we lost time */
    747      1.21    cegger 			free(out, M_CRYPTO_DATA);
    748       1.1  jonathan 			return 0;
    749       1.1  jonathan 	}
    750       1.1  jonathan 
    751       1.1  jonathan 	COPYBACK(outtype, buf, crd->crd_skip, result, out);
    752       1.1  jonathan 	if (result < crd->crd_len) {
    753       1.1  jonathan 		adj = result - crd->crd_len;
    754       1.1  jonathan 		if (outtype == CRYPTO_BUF_MBUF) {
    755       1.1  jonathan 			adj = result - crd->crd_len;
    756       1.1  jonathan 			m_adj((struct mbuf *)buf, adj);
    757       1.1  jonathan 		}
    758      1.24    darran 		/* Don't adjust the iov_len, it breaks the kmem_free */
    759       1.1  jonathan 	}
    760      1.21    cegger 	free(out, M_CRYPTO_DATA);
    761       1.1  jonathan 	return 0;
    762       1.1  jonathan }
    763       1.1  jonathan 
    764       1.1  jonathan /*
    765       1.1  jonathan  * Generate a new software session.
    766       1.1  jonathan  */
    767       1.1  jonathan static int
    768      1.15  christos swcr_newsession(void *arg, u_int32_t *sid, struct cryptoini *cri)
    769       1.1  jonathan {
    770       1.1  jonathan 	struct swcr_data **swd;
    771      1.10   thorpej 	const struct swcr_auth_hash *axf;
    772      1.10   thorpej 	const struct swcr_enc_xform *txf;
    773      1.10   thorpej 	const struct swcr_comp_algo *cxf;
    774       1.1  jonathan 	u_int32_t i;
    775       1.1  jonathan 	int k, error;
    776       1.1  jonathan 
    777       1.1  jonathan 	if (sid == NULL || cri == NULL)
    778       1.1  jonathan 		return EINVAL;
    779       1.1  jonathan 
    780       1.1  jonathan 	if (swcr_sessions) {
    781       1.1  jonathan 		for (i = 1; i < swcr_sesnum; i++)
    782       1.1  jonathan 			if (swcr_sessions[i] == NULL)
    783       1.1  jonathan 				break;
    784       1.1  jonathan 	} else
    785       1.1  jonathan 		i = 1;		/* NB: to silence compiler warning */
    786       1.1  jonathan 
    787       1.1  jonathan 	if (swcr_sessions == NULL || i == swcr_sesnum) {
    788       1.1  jonathan 		if (swcr_sessions == NULL) {
    789       1.1  jonathan 			i = 1; /* We leave swcr_sessions[0] empty */
    790       1.1  jonathan 			swcr_sesnum = CRYPTO_SW_SESSIONS;
    791       1.1  jonathan 		} else
    792       1.1  jonathan 			swcr_sesnum *= 2;
    793       1.1  jonathan 
    794       1.1  jonathan 		swd = malloc(swcr_sesnum * sizeof(struct swcr_data *),
    795       1.1  jonathan 		    M_CRYPTO_DATA, M_NOWAIT);
    796       1.1  jonathan 		if (swd == NULL) {
    797       1.1  jonathan 			/* Reset session number */
    798       1.1  jonathan 			if (swcr_sesnum == CRYPTO_SW_SESSIONS)
    799       1.1  jonathan 				swcr_sesnum = 0;
    800       1.1  jonathan 			else
    801       1.1  jonathan 				swcr_sesnum /= 2;
    802       1.1  jonathan 			return ENOBUFS;
    803       1.1  jonathan 		}
    804       1.1  jonathan 
    805      1.22    cegger 		memset(swd, 0, swcr_sesnum * sizeof(struct swcr_data *));
    806       1.1  jonathan 
    807       1.1  jonathan 		/* Copy existing sessions */
    808       1.1  jonathan 		if (swcr_sessions) {
    809      1.25   tsutsui 			memcpy(swd, swcr_sessions,
    810       1.1  jonathan 			    (swcr_sesnum / 2) * sizeof(struct swcr_data *));
    811       1.1  jonathan 			free(swcr_sessions, M_CRYPTO_DATA);
    812       1.1  jonathan 		}
    813       1.1  jonathan 
    814       1.1  jonathan 		swcr_sessions = swd;
    815       1.1  jonathan 	}
    816       1.1  jonathan 
    817       1.1  jonathan 	swd = &swcr_sessions[i];
    818       1.1  jonathan 	*sid = i;
    819       1.1  jonathan 
    820       1.1  jonathan 	while (cri) {
    821      1.13       dsl 		*swd = malloc(sizeof **swd, M_CRYPTO_DATA, M_NOWAIT);
    822       1.1  jonathan 		if (*swd == NULL) {
    823       1.1  jonathan 			swcr_freesession(NULL, i);
    824       1.1  jonathan 			return ENOBUFS;
    825       1.1  jonathan 		}
    826      1.22    cegger 		memset(*swd, 0, sizeof(struct swcr_data));
    827       1.1  jonathan 
    828       1.1  jonathan 		switch (cri->cri_alg) {
    829       1.1  jonathan 		case CRYPTO_DES_CBC:
    830      1.10   thorpej 			txf = &swcr_enc_xform_des;
    831       1.1  jonathan 			goto enccommon;
    832       1.1  jonathan 		case CRYPTO_3DES_CBC:
    833      1.10   thorpej 			txf = &swcr_enc_xform_3des;
    834       1.1  jonathan 			goto enccommon;
    835       1.1  jonathan 		case CRYPTO_BLF_CBC:
    836      1.10   thorpej 			txf = &swcr_enc_xform_blf;
    837       1.1  jonathan 			goto enccommon;
    838       1.1  jonathan 		case CRYPTO_CAST_CBC:
    839      1.10   thorpej 			txf = &swcr_enc_xform_cast5;
    840       1.1  jonathan 			goto enccommon;
    841       1.1  jonathan 		case CRYPTO_SKIPJACK_CBC:
    842      1.10   thorpej 			txf = &swcr_enc_xform_skipjack;
    843       1.1  jonathan 			goto enccommon;
    844       1.1  jonathan 		case CRYPTO_RIJNDAEL128_CBC:
    845      1.10   thorpej 			txf = &swcr_enc_xform_rijndael128;
    846       1.1  jonathan 			goto enccommon;
    847      1.30  drochner 		case CRYPTO_CAMELLIA_CBC:
    848      1.30  drochner 			txf = &swcr_enc_xform_camellia;
    849      1.30  drochner 			goto enccommon;
    850      1.33  drochner 		case CRYPTO_AES_CTR:
    851      1.33  drochner 			txf = &swcr_enc_xform_aes_ctr;
    852      1.33  drochner 			goto enccommon;
    853      1.37  drochner 		case CRYPTO_AES_GCM_16:
    854      1.37  drochner 			txf = &swcr_enc_xform_aes_gcm;
    855      1.37  drochner 			goto enccommon;
    856      1.38  drochner 		case CRYPTO_AES_GMAC:
    857      1.38  drochner 			txf = &swcr_enc_xform_aes_gmac;
    858      1.38  drochner 			goto enccommon;
    859       1.1  jonathan 		case CRYPTO_NULL_CBC:
    860      1.10   thorpej 			txf = &swcr_enc_xform_null;
    861       1.1  jonathan 			goto enccommon;
    862       1.1  jonathan 		enccommon:
    863       1.1  jonathan 			error = txf->setkey(&((*swd)->sw_kschedule),
    864       1.1  jonathan 					cri->cri_key, cri->cri_klen / 8);
    865       1.1  jonathan 			if (error) {
    866       1.1  jonathan 				swcr_freesession(NULL, i);
    867       1.1  jonathan 				return error;
    868       1.1  jonathan 			}
    869       1.1  jonathan 			(*swd)->sw_exf = txf;
    870       1.1  jonathan 			break;
    871       1.1  jonathan 
    872       1.1  jonathan 		case CRYPTO_MD5_HMAC:
    873      1.19       tls 			axf = &swcr_auth_hash_hmac_md5;
    874      1.19       tls 			goto authcommon;
    875      1.19       tls 		case CRYPTO_MD5_HMAC_96:
    876      1.10   thorpej 			axf = &swcr_auth_hash_hmac_md5_96;
    877       1.1  jonathan 			goto authcommon;
    878       1.1  jonathan 		case CRYPTO_SHA1_HMAC:
    879      1.19       tls 			axf = &swcr_auth_hash_hmac_sha1;
    880      1.19       tls 			goto authcommon;
    881      1.19       tls 		case CRYPTO_SHA1_HMAC_96:
    882      1.10   thorpej 			axf = &swcr_auth_hash_hmac_sha1_96;
    883       1.1  jonathan 			goto authcommon;
    884      1.29  drochner 		case CRYPTO_SHA2_256_HMAC:
    885      1.29  drochner 			axf = &swcr_auth_hash_hmac_sha2_256;
    886      1.29  drochner 			goto authcommon;
    887      1.29  drochner 		case CRYPTO_SHA2_384_HMAC:
    888      1.29  drochner 			axf = &swcr_auth_hash_hmac_sha2_384;
    889      1.29  drochner 			goto authcommon;
    890      1.29  drochner 		case CRYPTO_SHA2_512_HMAC:
    891      1.29  drochner 			axf = &swcr_auth_hash_hmac_sha2_512;
    892       1.1  jonathan 			goto authcommon;
    893       1.1  jonathan 		case CRYPTO_NULL_HMAC:
    894      1.10   thorpej 			axf = &swcr_auth_hash_null;
    895       1.1  jonathan 			goto authcommon;
    896       1.1  jonathan 		case CRYPTO_RIPEMD160_HMAC:
    897      1.19       tls 			axf = &swcr_auth_hash_hmac_ripemd_160;
    898      1.19       tls 			goto authcommon;
    899      1.19       tls 		case CRYPTO_RIPEMD160_HMAC_96:
    900      1.10   thorpej 			axf = &swcr_auth_hash_hmac_ripemd_160_96;
    901      1.19       tls 			goto authcommon;	/* leave this for safety */
    902       1.1  jonathan 		authcommon:
    903      1.35  drochner 			(*swd)->sw_ictx = malloc(axf->ctxsize,
    904      1.10   thorpej 			    M_CRYPTO_DATA, M_NOWAIT);
    905       1.1  jonathan 			if ((*swd)->sw_ictx == NULL) {
    906       1.1  jonathan 				swcr_freesession(NULL, i);
    907       1.1  jonathan 				return ENOBUFS;
    908       1.1  jonathan 			}
    909       1.1  jonathan 
    910      1.35  drochner 			(*swd)->sw_octx = malloc(axf->ctxsize,
    911      1.10   thorpej 			    M_CRYPTO_DATA, M_NOWAIT);
    912       1.1  jonathan 			if ((*swd)->sw_octx == NULL) {
    913       1.1  jonathan 				swcr_freesession(NULL, i);
    914       1.1  jonathan 				return ENOBUFS;
    915       1.1  jonathan 			}
    916       1.1  jonathan 
    917       1.1  jonathan 			for (k = 0; k < cri->cri_klen / 8; k++)
    918       1.1  jonathan 				cri->cri_key[k] ^= HMAC_IPAD_VAL;
    919       1.1  jonathan 
    920       1.1  jonathan 			axf->Init((*swd)->sw_ictx);
    921       1.1  jonathan 			axf->Update((*swd)->sw_ictx, cri->cri_key,
    922       1.1  jonathan 			    cri->cri_klen / 8);
    923       1.1  jonathan 			axf->Update((*swd)->sw_ictx, hmac_ipad_buffer,
    924      1.29  drochner 			    axf->auth_hash->blocksize - (cri->cri_klen / 8));
    925       1.1  jonathan 
    926       1.1  jonathan 			for (k = 0; k < cri->cri_klen / 8; k++)
    927       1.1  jonathan 				cri->cri_key[k] ^= (HMAC_IPAD_VAL ^ HMAC_OPAD_VAL);
    928       1.1  jonathan 
    929       1.1  jonathan 			axf->Init((*swd)->sw_octx);
    930       1.1  jonathan 			axf->Update((*swd)->sw_octx, cri->cri_key,
    931       1.1  jonathan 			    cri->cri_klen / 8);
    932       1.1  jonathan 			axf->Update((*swd)->sw_octx, hmac_opad_buffer,
    933      1.29  drochner 			    axf->auth_hash->blocksize - (cri->cri_klen / 8));
    934       1.1  jonathan 
    935       1.1  jonathan 			for (k = 0; k < cri->cri_klen / 8; k++)
    936       1.1  jonathan 				cri->cri_key[k] ^= HMAC_OPAD_VAL;
    937       1.1  jonathan 			(*swd)->sw_axf = axf;
    938       1.1  jonathan 			break;
    939       1.1  jonathan 
    940       1.1  jonathan 		case CRYPTO_MD5_KPDK:
    941      1.10   thorpej 			axf = &swcr_auth_hash_key_md5;
    942       1.1  jonathan 			goto auth2common;
    943       1.1  jonathan 
    944       1.1  jonathan 		case CRYPTO_SHA1_KPDK:
    945      1.10   thorpej 			axf = &swcr_auth_hash_key_sha1;
    946       1.1  jonathan 		auth2common:
    947      1.35  drochner 			(*swd)->sw_ictx = malloc(axf->ctxsize,
    948      1.10   thorpej 			    M_CRYPTO_DATA, M_NOWAIT);
    949       1.1  jonathan 			if ((*swd)->sw_ictx == NULL) {
    950       1.1  jonathan 				swcr_freesession(NULL, i);
    951       1.1  jonathan 				return ENOBUFS;
    952       1.1  jonathan 			}
    953       1.1  jonathan 
    954       1.1  jonathan 			/* Store the key so we can "append" it to the payload */
    955       1.1  jonathan 			(*swd)->sw_octx = malloc(cri->cri_klen / 8, M_CRYPTO_DATA,
    956       1.1  jonathan 			    M_NOWAIT);
    957       1.1  jonathan 			if ((*swd)->sw_octx == NULL) {
    958       1.1  jonathan 				swcr_freesession(NULL, i);
    959       1.1  jonathan 				return ENOBUFS;
    960       1.1  jonathan 			}
    961       1.1  jonathan 
    962       1.1  jonathan 			(*swd)->sw_klen = cri->cri_klen / 8;
    963      1.25   tsutsui 			memcpy((*swd)->sw_octx, cri->cri_key, cri->cri_klen / 8);
    964       1.1  jonathan 			axf->Init((*swd)->sw_ictx);
    965       1.1  jonathan 			axf->Update((*swd)->sw_ictx, cri->cri_key,
    966       1.1  jonathan 			    cri->cri_klen / 8);
    967       1.1  jonathan 			axf->Final(NULL, (*swd)->sw_ictx);
    968       1.1  jonathan 			(*swd)->sw_axf = axf;
    969       1.1  jonathan 			break;
    970       1.1  jonathan 
    971       1.1  jonathan 		case CRYPTO_MD5:
    972      1.10   thorpej 			axf = &swcr_auth_hash_md5;
    973       1.1  jonathan 			goto auth3common;
    974       1.1  jonathan 
    975       1.1  jonathan 		case CRYPTO_SHA1:
    976      1.10   thorpej 			axf = &swcr_auth_hash_sha1;
    977       1.1  jonathan 		auth3common:
    978      1.35  drochner 			(*swd)->sw_ictx = malloc(axf->ctxsize,
    979      1.10   thorpej 			    M_CRYPTO_DATA, M_NOWAIT);
    980       1.1  jonathan 			if ((*swd)->sw_ictx == NULL) {
    981       1.1  jonathan 				swcr_freesession(NULL, i);
    982       1.1  jonathan 				return ENOBUFS;
    983       1.1  jonathan 			}
    984       1.1  jonathan 
    985       1.1  jonathan 			axf->Init((*swd)->sw_ictx);
    986       1.1  jonathan 			(*swd)->sw_axf = axf;
    987       1.1  jonathan 			break;
    988       1.1  jonathan 
    989      1.36  drochner 		case CRYPTO_AES_XCBC_MAC_96:
    990      1.36  drochner 			axf = &swcr_auth_hash_aes_xcbc_mac;
    991      1.37  drochner 			goto auth4common;
    992      1.37  drochner 		case CRYPTO_AES_128_GMAC:
    993      1.37  drochner 			axf = &swcr_auth_hash_gmac_aes_128;
    994      1.37  drochner 			goto auth4common;
    995      1.37  drochner 		case CRYPTO_AES_192_GMAC:
    996      1.37  drochner 			axf = &swcr_auth_hash_gmac_aes_192;
    997      1.37  drochner 			goto auth4common;
    998      1.37  drochner 		case CRYPTO_AES_256_GMAC:
    999      1.37  drochner 			axf = &swcr_auth_hash_gmac_aes_256;
   1000      1.37  drochner 		auth4common:
   1001      1.36  drochner 			(*swd)->sw_ictx = malloc(axf->ctxsize,
   1002      1.36  drochner 			    M_CRYPTO_DATA, M_NOWAIT);
   1003      1.36  drochner 			if ((*swd)->sw_ictx == NULL) {
   1004      1.36  drochner 				swcr_freesession(NULL, i);
   1005      1.36  drochner 				return ENOBUFS;
   1006      1.36  drochner 			}
   1007      1.36  drochner 			axf->Init((*swd)->sw_ictx);
   1008      1.36  drochner 			axf->Setkey((*swd)->sw_ictx,
   1009      1.36  drochner 				cri->cri_key, cri->cri_klen / 8);
   1010      1.36  drochner 			(*swd)->sw_axf = axf;
   1011      1.36  drochner 			break;
   1012      1.36  drochner 
   1013       1.1  jonathan 		case CRYPTO_DEFLATE_COMP:
   1014      1.10   thorpej 			cxf = &swcr_comp_algo_deflate;
   1015       1.1  jonathan 			(*swd)->sw_cxf = cxf;
   1016       1.1  jonathan 			break;
   1017      1.24    darran 
   1018      1.28  drochner 		case CRYPTO_DEFLATE_COMP_NOGROW:
   1019      1.28  drochner 			cxf = &swcr_comp_algo_deflate_nogrow;
   1020      1.28  drochner 			(*swd)->sw_cxf = cxf;
   1021      1.28  drochner 			break;
   1022      1.28  drochner 
   1023      1.24    darran 		case CRYPTO_GZIP_COMP:
   1024      1.24    darran 			cxf = &swcr_comp_algo_gzip;
   1025      1.24    darran 			(*swd)->sw_cxf = cxf;
   1026      1.24    darran 			break;
   1027       1.1  jonathan 		default:
   1028       1.1  jonathan 			swcr_freesession(NULL, i);
   1029       1.1  jonathan 			return EINVAL;
   1030       1.1  jonathan 		}
   1031       1.1  jonathan 
   1032       1.1  jonathan 		(*swd)->sw_alg = cri->cri_alg;
   1033       1.1  jonathan 		cri = cri->cri_next;
   1034       1.1  jonathan 		swd = &((*swd)->sw_next);
   1035       1.1  jonathan 	}
   1036       1.1  jonathan 	return 0;
   1037       1.1  jonathan }
   1038       1.1  jonathan 
   1039       1.1  jonathan /*
   1040       1.1  jonathan  * Free a session.
   1041       1.1  jonathan  */
   1042       1.1  jonathan static int
   1043      1.15  christos swcr_freesession(void *arg, u_int64_t tid)
   1044       1.1  jonathan {
   1045       1.1  jonathan 	struct swcr_data *swd;
   1046      1.10   thorpej 	const struct swcr_enc_xform *txf;
   1047      1.10   thorpej 	const struct swcr_auth_hash *axf;
   1048      1.10   thorpej 	const struct swcr_comp_algo *cxf;
   1049       1.1  jonathan 	u_int32_t sid = ((u_int32_t) tid) & 0xffffffff;
   1050       1.1  jonathan 
   1051       1.1  jonathan 	if (sid > swcr_sesnum || swcr_sessions == NULL ||
   1052       1.1  jonathan 	    swcr_sessions[sid] == NULL)
   1053       1.1  jonathan 		return EINVAL;
   1054       1.1  jonathan 
   1055       1.1  jonathan 	/* Silently accept and return */
   1056       1.1  jonathan 	if (sid == 0)
   1057       1.1  jonathan 		return 0;
   1058       1.1  jonathan 
   1059       1.1  jonathan 	while ((swd = swcr_sessions[sid]) != NULL) {
   1060       1.1  jonathan 		swcr_sessions[sid] = swd->sw_next;
   1061       1.1  jonathan 
   1062       1.1  jonathan 		switch (swd->sw_alg) {
   1063       1.1  jonathan 		case CRYPTO_DES_CBC:
   1064       1.1  jonathan 		case CRYPTO_3DES_CBC:
   1065       1.1  jonathan 		case CRYPTO_BLF_CBC:
   1066       1.1  jonathan 		case CRYPTO_CAST_CBC:
   1067       1.1  jonathan 		case CRYPTO_SKIPJACK_CBC:
   1068       1.1  jonathan 		case CRYPTO_RIJNDAEL128_CBC:
   1069      1.30  drochner 		case CRYPTO_CAMELLIA_CBC:
   1070      1.33  drochner 		case CRYPTO_AES_CTR:
   1071      1.37  drochner 		case CRYPTO_AES_GCM_16:
   1072      1.38  drochner 		case CRYPTO_AES_GMAC:
   1073       1.1  jonathan 		case CRYPTO_NULL_CBC:
   1074       1.1  jonathan 			txf = swd->sw_exf;
   1075       1.1  jonathan 
   1076       1.1  jonathan 			if (swd->sw_kschedule)
   1077       1.1  jonathan 				txf->zerokey(&(swd->sw_kschedule));
   1078       1.1  jonathan 			break;
   1079       1.1  jonathan 
   1080       1.1  jonathan 		case CRYPTO_MD5_HMAC:
   1081      1.19       tls 		case CRYPTO_MD5_HMAC_96:
   1082       1.1  jonathan 		case CRYPTO_SHA1_HMAC:
   1083      1.19       tls 		case CRYPTO_SHA1_HMAC_96:
   1084      1.29  drochner 		case CRYPTO_SHA2_256_HMAC:
   1085      1.29  drochner 		case CRYPTO_SHA2_384_HMAC:
   1086      1.29  drochner 		case CRYPTO_SHA2_512_HMAC:
   1087       1.1  jonathan 		case CRYPTO_RIPEMD160_HMAC:
   1088      1.19       tls 		case CRYPTO_RIPEMD160_HMAC_96:
   1089       1.1  jonathan 		case CRYPTO_NULL_HMAC:
   1090       1.1  jonathan 			axf = swd->sw_axf;
   1091       1.1  jonathan 
   1092       1.1  jonathan 			if (swd->sw_ictx) {
   1093      1.40  drochner 				explicit_bzero(swd->sw_ictx, axf->ctxsize);
   1094       1.1  jonathan 				free(swd->sw_ictx, M_CRYPTO_DATA);
   1095       1.1  jonathan 			}
   1096       1.1  jonathan 			if (swd->sw_octx) {
   1097      1.40  drochner 				explicit_bzero(swd->sw_octx, axf->ctxsize);
   1098       1.1  jonathan 				free(swd->sw_octx, M_CRYPTO_DATA);
   1099       1.1  jonathan 			}
   1100       1.1  jonathan 			break;
   1101       1.1  jonathan 
   1102       1.1  jonathan 		case CRYPTO_MD5_KPDK:
   1103       1.1  jonathan 		case CRYPTO_SHA1_KPDK:
   1104       1.1  jonathan 			axf = swd->sw_axf;
   1105       1.1  jonathan 
   1106       1.1  jonathan 			if (swd->sw_ictx) {
   1107      1.40  drochner 				explicit_bzero(swd->sw_ictx, axf->ctxsize);
   1108       1.1  jonathan 				free(swd->sw_ictx, M_CRYPTO_DATA);
   1109       1.1  jonathan 			}
   1110       1.1  jonathan 			if (swd->sw_octx) {
   1111      1.40  drochner 				explicit_bzero(swd->sw_octx, swd->sw_klen);
   1112       1.1  jonathan 				free(swd->sw_octx, M_CRYPTO_DATA);
   1113       1.1  jonathan 			}
   1114       1.1  jonathan 			break;
   1115       1.1  jonathan 
   1116       1.1  jonathan 		case CRYPTO_MD5:
   1117       1.1  jonathan 		case CRYPTO_SHA1:
   1118      1.36  drochner 		case CRYPTO_AES_XCBC_MAC_96:
   1119      1.37  drochner 		case CRYPTO_AES_128_GMAC:
   1120      1.37  drochner 		case CRYPTO_AES_192_GMAC:
   1121      1.37  drochner 		case CRYPTO_AES_256_GMAC:
   1122       1.1  jonathan 			axf = swd->sw_axf;
   1123       1.1  jonathan 
   1124      1.40  drochner 			if (swd->sw_ictx) {
   1125      1.40  drochner 				explicit_bzero(swd->sw_ictx, axf->ctxsize);
   1126       1.1  jonathan 				free(swd->sw_ictx, M_CRYPTO_DATA);
   1127      1.40  drochner 			}
   1128       1.1  jonathan 			break;
   1129       1.1  jonathan 
   1130       1.1  jonathan 		case CRYPTO_DEFLATE_COMP:
   1131      1.28  drochner 		case CRYPTO_DEFLATE_COMP_NOGROW:
   1132      1.24    darran 		case CRYPTO_GZIP_COMP:
   1133       1.1  jonathan 			cxf = swd->sw_cxf;
   1134       1.1  jonathan 			break;
   1135       1.1  jonathan 		}
   1136       1.1  jonathan 
   1137      1.21    cegger 		free(swd, M_CRYPTO_DATA);
   1138       1.1  jonathan 	}
   1139       1.1  jonathan 	return 0;
   1140       1.1  jonathan }
   1141       1.1  jonathan 
   1142       1.1  jonathan /*
   1143       1.1  jonathan  * Process a software request.
   1144       1.1  jonathan  */
   1145       1.1  jonathan static int
   1146      1.15  christos swcr_process(void *arg, struct cryptop *crp, int hint)
   1147       1.1  jonathan {
   1148       1.1  jonathan 	struct cryptodesc *crd;
   1149       1.1  jonathan 	struct swcr_data *sw;
   1150       1.1  jonathan 	u_int32_t lid;
   1151       1.1  jonathan 	int type;
   1152       1.1  jonathan 
   1153       1.1  jonathan 	/* Sanity check */
   1154       1.1  jonathan 	if (crp == NULL)
   1155       1.1  jonathan 		return EINVAL;
   1156       1.1  jonathan 
   1157       1.1  jonathan 	if (crp->crp_desc == NULL || crp->crp_buf == NULL) {
   1158       1.1  jonathan 		crp->crp_etype = EINVAL;
   1159       1.1  jonathan 		goto done;
   1160       1.1  jonathan 	}
   1161       1.1  jonathan 
   1162       1.1  jonathan 	lid = crp->crp_sid & 0xffffffff;
   1163       1.1  jonathan 	if (lid >= swcr_sesnum || lid == 0 || swcr_sessions[lid] == NULL) {
   1164       1.1  jonathan 		crp->crp_etype = ENOENT;
   1165       1.1  jonathan 		goto done;
   1166       1.1  jonathan 	}
   1167       1.1  jonathan 
   1168       1.1  jonathan 	if (crp->crp_flags & CRYPTO_F_IMBUF) {
   1169       1.1  jonathan 		type = CRYPTO_BUF_MBUF;
   1170       1.1  jonathan 	} else if (crp->crp_flags & CRYPTO_F_IOV) {
   1171       1.1  jonathan 		type = CRYPTO_BUF_IOV;
   1172       1.1  jonathan 	} else {
   1173       1.1  jonathan 		type = CRYPTO_BUF_CONTIG;
   1174       1.1  jonathan 	}
   1175       1.1  jonathan 
   1176       1.1  jonathan 	/* Go through crypto descriptors, processing as we go */
   1177       1.1  jonathan 	for (crd = crp->crp_desc; crd; crd = crd->crd_next) {
   1178       1.1  jonathan 		/*
   1179       1.1  jonathan 		 * Find the crypto context.
   1180       1.1  jonathan 		 *
   1181       1.1  jonathan 		 * XXX Note that the logic here prevents us from having
   1182       1.1  jonathan 		 * XXX the same algorithm multiple times in a session
   1183       1.1  jonathan 		 * XXX (or rather, we can but it won't give us the right
   1184       1.1  jonathan 		 * XXX results). To do that, we'd need some way of differentiating
   1185       1.1  jonathan 		 * XXX between the various instances of an algorithm (so we can
   1186       1.1  jonathan 		 * XXX locate the correct crypto context).
   1187       1.1  jonathan 		 */
   1188       1.1  jonathan 		for (sw = swcr_sessions[lid];
   1189       1.1  jonathan 		    sw && sw->sw_alg != crd->crd_alg;
   1190       1.1  jonathan 		    sw = sw->sw_next)
   1191       1.1  jonathan 			;
   1192       1.1  jonathan 
   1193       1.1  jonathan 		/* No such context ? */
   1194       1.1  jonathan 		if (sw == NULL) {
   1195       1.1  jonathan 			crp->crp_etype = EINVAL;
   1196       1.1  jonathan 			goto done;
   1197       1.1  jonathan 		}
   1198       1.1  jonathan 
   1199       1.1  jonathan 		switch (sw->sw_alg) {
   1200       1.1  jonathan 		case CRYPTO_DES_CBC:
   1201       1.1  jonathan 		case CRYPTO_3DES_CBC:
   1202       1.1  jonathan 		case CRYPTO_BLF_CBC:
   1203       1.1  jonathan 		case CRYPTO_CAST_CBC:
   1204       1.1  jonathan 		case CRYPTO_SKIPJACK_CBC:
   1205       1.1  jonathan 		case CRYPTO_RIJNDAEL128_CBC:
   1206      1.30  drochner 		case CRYPTO_CAMELLIA_CBC:
   1207      1.33  drochner 		case CRYPTO_AES_CTR:
   1208       1.1  jonathan 			if ((crp->crp_etype = swcr_encdec(crd, sw,
   1209       1.1  jonathan 			    crp->crp_buf, type)) != 0)
   1210       1.1  jonathan 				goto done;
   1211       1.1  jonathan 			break;
   1212       1.1  jonathan 		case CRYPTO_NULL_CBC:
   1213       1.1  jonathan 			crp->crp_etype = 0;
   1214       1.1  jonathan 			break;
   1215       1.1  jonathan 		case CRYPTO_MD5_HMAC:
   1216      1.19       tls 		case CRYPTO_MD5_HMAC_96:
   1217       1.1  jonathan 		case CRYPTO_SHA1_HMAC:
   1218      1.19       tls 		case CRYPTO_SHA1_HMAC_96:
   1219      1.29  drochner 		case CRYPTO_SHA2_256_HMAC:
   1220      1.29  drochner 		case CRYPTO_SHA2_384_HMAC:
   1221      1.29  drochner 		case CRYPTO_SHA2_512_HMAC:
   1222       1.1  jonathan 		case CRYPTO_RIPEMD160_HMAC:
   1223      1.19       tls 		case CRYPTO_RIPEMD160_HMAC_96:
   1224       1.1  jonathan 		case CRYPTO_NULL_HMAC:
   1225       1.1  jonathan 		case CRYPTO_MD5_KPDK:
   1226       1.1  jonathan 		case CRYPTO_SHA1_KPDK:
   1227       1.1  jonathan 		case CRYPTO_MD5:
   1228       1.1  jonathan 		case CRYPTO_SHA1:
   1229      1.36  drochner 		case CRYPTO_AES_XCBC_MAC_96:
   1230       1.1  jonathan 			if ((crp->crp_etype = swcr_authcompute(crp, crd, sw,
   1231       1.1  jonathan 			    crp->crp_buf, type)) != 0)
   1232       1.1  jonathan 				goto done;
   1233       1.1  jonathan 			break;
   1234       1.1  jonathan 
   1235      1.37  drochner 		case CRYPTO_AES_GCM_16:
   1236      1.37  drochner 		case CRYPTO_AES_GMAC:
   1237      1.37  drochner 		case CRYPTO_AES_128_GMAC:
   1238      1.37  drochner 		case CRYPTO_AES_192_GMAC:
   1239      1.37  drochner 		case CRYPTO_AES_256_GMAC:
   1240      1.37  drochner 			crp->crp_etype = swcr_combined(crp, type);
   1241      1.37  drochner 			goto done;
   1242      1.37  drochner 
   1243       1.1  jonathan 		case CRYPTO_DEFLATE_COMP:
   1244      1.28  drochner 		case CRYPTO_DEFLATE_COMP_NOGROW:
   1245      1.24    darran 		case CRYPTO_GZIP_COMP:
   1246      1.24    darran 			DPRINTF(("swcr_process: compdec for %d\n", sw->sw_alg));
   1247       1.9     perry 			if ((crp->crp_etype = swcr_compdec(crd, sw,
   1248      1.27  drochner 			    crp->crp_buf, type, &crp->crp_olen)) != 0)
   1249       1.1  jonathan 				goto done;
   1250       1.1  jonathan 			break;
   1251       1.1  jonathan 
   1252       1.1  jonathan 		default:
   1253       1.1  jonathan 			/* Unknown/unsupported algorithm */
   1254       1.1  jonathan 			crp->crp_etype = EINVAL;
   1255       1.1  jonathan 			goto done;
   1256       1.1  jonathan 		}
   1257       1.1  jonathan 	}
   1258       1.1  jonathan 
   1259       1.1  jonathan done:
   1260      1.26  jakllsch 	DPRINTF(("request %p done\n", crp));
   1261       1.1  jonathan 	crypto_done(crp);
   1262       1.1  jonathan 	return 0;
   1263       1.1  jonathan }
   1264       1.1  jonathan 
   1265      1.10   thorpej static void
   1266       1.1  jonathan swcr_init(void)
   1267       1.1  jonathan {
   1268       1.1  jonathan 	swcr_id = crypto_get_driverid(CRYPTOCAP_F_SOFTWARE);
   1269       1.1  jonathan 	if (swcr_id < 0) {
   1270       1.1  jonathan 		/* This should never happen */
   1271       1.1  jonathan 		panic("Software crypto device cannot initialize!");
   1272       1.1  jonathan 	}
   1273       1.1  jonathan 
   1274       1.1  jonathan 	crypto_register(swcr_id, CRYPTO_DES_CBC,
   1275       1.1  jonathan 	    0, 0, swcr_newsession, swcr_freesession, swcr_process, NULL);
   1276       1.1  jonathan #define	REGISTER(alg) \
   1277       1.1  jonathan 	crypto_register(swcr_id, alg, 0, 0, NULL, NULL, NULL, NULL)
   1278       1.1  jonathan 
   1279       1.1  jonathan 	REGISTER(CRYPTO_3DES_CBC);
   1280       1.1  jonathan 	REGISTER(CRYPTO_BLF_CBC);
   1281       1.1  jonathan 	REGISTER(CRYPTO_CAST_CBC);
   1282       1.1  jonathan 	REGISTER(CRYPTO_SKIPJACK_CBC);
   1283      1.30  drochner 	REGISTER(CRYPTO_CAMELLIA_CBC);
   1284      1.33  drochner 	REGISTER(CRYPTO_AES_CTR);
   1285      1.37  drochner 	REGISTER(CRYPTO_AES_GCM_16);
   1286      1.37  drochner 	REGISTER(CRYPTO_AES_GMAC);
   1287       1.1  jonathan 	REGISTER(CRYPTO_NULL_CBC);
   1288       1.1  jonathan 	REGISTER(CRYPTO_MD5_HMAC);
   1289      1.19       tls 	REGISTER(CRYPTO_MD5_HMAC_96);
   1290       1.1  jonathan 	REGISTER(CRYPTO_SHA1_HMAC);
   1291      1.19       tls 	REGISTER(CRYPTO_SHA1_HMAC_96);
   1292      1.29  drochner 	REGISTER(CRYPTO_SHA2_256_HMAC);
   1293      1.29  drochner 	REGISTER(CRYPTO_SHA2_384_HMAC);
   1294      1.29  drochner 	REGISTER(CRYPTO_SHA2_512_HMAC);
   1295       1.1  jonathan 	REGISTER(CRYPTO_RIPEMD160_HMAC);
   1296      1.19       tls 	REGISTER(CRYPTO_RIPEMD160_HMAC_96);
   1297       1.1  jonathan 	REGISTER(CRYPTO_NULL_HMAC);
   1298       1.1  jonathan 	REGISTER(CRYPTO_MD5_KPDK);
   1299       1.1  jonathan 	REGISTER(CRYPTO_SHA1_KPDK);
   1300       1.1  jonathan 	REGISTER(CRYPTO_MD5);
   1301       1.1  jonathan 	REGISTER(CRYPTO_SHA1);
   1302      1.36  drochner 	REGISTER(CRYPTO_AES_XCBC_MAC_96);
   1303      1.37  drochner 	REGISTER(CRYPTO_AES_128_GMAC);
   1304      1.37  drochner 	REGISTER(CRYPTO_AES_192_GMAC);
   1305      1.37  drochner 	REGISTER(CRYPTO_AES_256_GMAC);
   1306       1.1  jonathan 	REGISTER(CRYPTO_RIJNDAEL128_CBC);
   1307       1.1  jonathan 	REGISTER(CRYPTO_DEFLATE_COMP);
   1308      1.28  drochner 	REGISTER(CRYPTO_DEFLATE_COMP_NOGROW);
   1309      1.24    darran 	REGISTER(CRYPTO_GZIP_COMP);
   1310       1.1  jonathan #undef REGISTER
   1311       1.1  jonathan }
   1312       1.1  jonathan 
   1313      1.10   thorpej 
   1314      1.10   thorpej /*
   1315      1.10   thorpej  * Pseudo-device init routine for software crypto.
   1316      1.10   thorpej  */
   1317      1.11   thorpej void	swcryptoattach(int);
   1318      1.10   thorpej 
   1319      1.10   thorpej void
   1320      1.15  christos swcryptoattach(int num)
   1321      1.10   thorpej {
   1322      1.10   thorpej 
   1323      1.10   thorpej 	swcr_init();
   1324      1.10   thorpej }
   1325