1091d81d1SSam Leffler /* $OpenBSD: cryptosoft.c,v 1.35 2002/04/26 08:43:50 deraadt Exp $ */ 2091d81d1SSam Leffler 360727d8bSWarner Losh /*- 4091d81d1SSam Leffler * The author of this code is Angelos D. Keromytis (angelos@cis.upenn.edu) 56810ad6fSSam Leffler * Copyright (c) 2002-2006 Sam Leffler, Errno Consulting 6091d81d1SSam Leffler * 7091d81d1SSam Leffler * This code was written by Angelos D. Keromytis in Athens, Greece, in 8091d81d1SSam Leffler * February 2000. Network Security Technologies Inc. (NSTI) kindly 9091d81d1SSam Leffler * supported the development of this code. 10091d81d1SSam Leffler * 11091d81d1SSam Leffler * Copyright (c) 2000, 2001 Angelos D. Keromytis 12091d81d1SSam Leffler * 13091d81d1SSam Leffler * Permission to use, copy, and modify this software with or without fee 14091d81d1SSam Leffler * is hereby granted, provided that this entire notice is included in 15091d81d1SSam Leffler * all source code copies of any software which is or includes a copy or 16091d81d1SSam Leffler * modification of this software. 17091d81d1SSam Leffler * 18091d81d1SSam Leffler * THIS SOFTWARE IS BEING PROVIDED "AS IS", WITHOUT ANY EXPRESS OR 19091d81d1SSam Leffler * IMPLIED WARRANTY. IN PARTICULAR, NONE OF THE AUTHORS MAKES ANY 20091d81d1SSam Leffler * REPRESENTATION OR WARRANTY OF ANY KIND CONCERNING THE 21091d81d1SSam Leffler * MERCHANTABILITY OF THIS SOFTWARE OR ITS FITNESS FOR ANY PARTICULAR 22091d81d1SSam Leffler * PURPOSE. 23091d81d1SSam Leffler */ 24091d81d1SSam Leffler 252c446514SDavid E. O'Brien #include <sys/cdefs.h> 262c446514SDavid E. O'Brien __FBSDID("$FreeBSD$"); 272c446514SDavid E. O'Brien 28091d81d1SSam Leffler #include <sys/param.h> 29091d81d1SSam Leffler #include <sys/systm.h> 30091d81d1SSam Leffler #include <sys/malloc.h> 31091d81d1SSam Leffler #include <sys/mbuf.h> 326810ad6fSSam Leffler #include <sys/module.h> 33091d81d1SSam Leffler #include <sys/sysctl.h> 34091d81d1SSam Leffler #include <sys/errno.h> 35091d81d1SSam Leffler #include <sys/random.h> 36091d81d1SSam Leffler #include <sys/kernel.h> 37091d81d1SSam Leffler #include <sys/uio.h> 38109919c6SBenno Rice #include <sys/lock.h> 39109919c6SBenno Rice #include <sys/rwlock.h> 40091d81d1SSam Leffler 41091d81d1SSam Leffler #include <crypto/blowfish/blowfish.h> 42091d81d1SSam Leffler #include <crypto/sha1.h> 43091d81d1SSam Leffler #include <opencrypto/rmd160.h> 449f65b10bSHajimu UMEMOTO #include <opencrypto/cast.h> 45091d81d1SSam Leffler #include <opencrypto/skipjack.h> 46091d81d1SSam Leffler #include <sys/md5.h> 47091d81d1SSam Leffler 48091d81d1SSam Leffler #include <opencrypto/cryptodev.h> 49091d81d1SSam Leffler #include <opencrypto/cryptosoft.h> 50091d81d1SSam Leffler #include <opencrypto/xform.h> 51091d81d1SSam Leffler 526810ad6fSSam Leffler #include <sys/kobj.h> 536810ad6fSSam Leffler #include <sys/bus.h> 546810ad6fSSam Leffler #include "cryptodev_if.h" 55091d81d1SSam Leffler 566810ad6fSSam Leffler static int32_t swcr_id; 576810ad6fSSam Leffler static struct swcr_data **swcr_sessions = NULL; 586810ad6fSSam Leffler static u_int32_t swcr_sesnum; 59109919c6SBenno Rice /* Protects swcr_sessions pointer, not data. */ 60109919c6SBenno Rice static struct rwlock swcr_sessions_lock; 616810ad6fSSam Leffler 626810ad6fSSam Leffler u_int8_t hmac_ipad_buffer[HMAC_MAX_BLOCK_LEN]; 636810ad6fSSam Leffler u_int8_t hmac_opad_buffer[HMAC_MAX_BLOCK_LEN]; 64091d81d1SSam Leffler 65091d81d1SSam Leffler static int swcr_encdec(struct cryptodesc *, struct swcr_data *, caddr_t, int); 66f34a967bSPawel Jakub Dawidek static int swcr_authcompute(struct cryptodesc *, struct swcr_data *, caddr_t, int); 67091d81d1SSam Leffler static int swcr_compdec(struct cryptodesc *, struct swcr_data *, caddr_t, int); 686810ad6fSSam Leffler static int swcr_freesession(device_t dev, u_int64_t tid); 69109919c6SBenno Rice static int swcr_freesession_locked(device_t dev, u_int64_t tid); 70091d81d1SSam Leffler 71091d81d1SSam Leffler /* 72091d81d1SSam Leffler * Apply a symmetric encryption/decryption algorithm. 73091d81d1SSam Leffler */ 74091d81d1SSam Leffler static int 75091d81d1SSam Leffler swcr_encdec(struct cryptodesc *crd, struct swcr_data *sw, caddr_t buf, 76f34a967bSPawel Jakub Dawidek int flags) 77091d81d1SSam Leffler { 78091d81d1SSam Leffler unsigned char iv[EALG_MAX_BLOCK_LEN], blk[EALG_MAX_BLOCK_LEN], *idat; 79091d81d1SSam Leffler unsigned char *ivp, piv[EALG_MAX_BLOCK_LEN]; 80091d81d1SSam Leffler struct enc_xform *exf; 81091d81d1SSam Leffler int i, k, j, blks; 82091d81d1SSam Leffler 83091d81d1SSam Leffler exf = sw->sw_exf; 84091d81d1SSam Leffler blks = exf->blocksize; 85091d81d1SSam Leffler 86091d81d1SSam Leffler /* Check for non-padded data */ 87091d81d1SSam Leffler if (crd->crd_len % blks) 88091d81d1SSam Leffler return EINVAL; 89091d81d1SSam Leffler 90091d81d1SSam Leffler /* Initialize the IV */ 91091d81d1SSam Leffler if (crd->crd_flags & CRD_F_ENCRYPT) { 92091d81d1SSam Leffler /* IV explicitly provided ? */ 93091d81d1SSam Leffler if (crd->crd_flags & CRD_F_IV_EXPLICIT) 94091d81d1SSam Leffler bcopy(crd->crd_iv, iv, blks); 9548b0f2e1SPawel Jakub Dawidek else 9648b0f2e1SPawel Jakub Dawidek arc4rand(iv, blks, 0); 97091d81d1SSam Leffler 98091d81d1SSam Leffler /* Do we need to write the IV */ 99f34a967bSPawel Jakub Dawidek if (!(crd->crd_flags & CRD_F_IV_PRESENT)) 100f34a967bSPawel Jakub Dawidek crypto_copyback(flags, buf, crd->crd_inject, blks, iv); 101091d81d1SSam Leffler 102091d81d1SSam Leffler } else { /* Decryption */ 103091d81d1SSam Leffler /* IV explicitly provided ? */ 104091d81d1SSam Leffler if (crd->crd_flags & CRD_F_IV_EXPLICIT) 105091d81d1SSam Leffler bcopy(crd->crd_iv, iv, blks); 106091d81d1SSam Leffler else { 107091d81d1SSam Leffler /* Get IV off buf */ 108f34a967bSPawel Jakub Dawidek crypto_copydata(flags, buf, crd->crd_inject, blks, iv); 109091d81d1SSam Leffler } 110091d81d1SSam Leffler } 111091d81d1SSam Leffler 112c740ae4bSPoul-Henning Kamp if (crd->crd_flags & CRD_F_KEY_EXPLICIT) { 113c740ae4bSPoul-Henning Kamp int error; 114c740ae4bSPoul-Henning Kamp 115c740ae4bSPoul-Henning Kamp if (sw->sw_kschedule) 116c740ae4bSPoul-Henning Kamp exf->zerokey(&(sw->sw_kschedule)); 117c740ae4bSPoul-Henning Kamp error = exf->setkey(&sw->sw_kschedule, 118c740ae4bSPoul-Henning Kamp crd->crd_key, crd->crd_klen / 8); 119c740ae4bSPoul-Henning Kamp if (error) 120c740ae4bSPoul-Henning Kamp return (error); 121c740ae4bSPoul-Henning Kamp } 122d295bdeeSPawel Jakub Dawidek 123091d81d1SSam Leffler ivp = iv; 124091d81d1SSam Leffler 125d295bdeeSPawel Jakub Dawidek /* 126d295bdeeSPawel Jakub Dawidek * xforms that provide a reinit method perform all IV 127d295bdeeSPawel Jakub Dawidek * handling themselves. 128d295bdeeSPawel Jakub Dawidek */ 129d295bdeeSPawel Jakub Dawidek if (exf->reinit) 130d295bdeeSPawel Jakub Dawidek exf->reinit(sw->sw_kschedule, iv); 131d295bdeeSPawel Jakub Dawidek 132f34a967bSPawel Jakub Dawidek if (flags & CRYPTO_F_IMBUF) { 133091d81d1SSam Leffler struct mbuf *m = (struct mbuf *) buf; 134091d81d1SSam Leffler 135091d81d1SSam Leffler /* Find beginning of data */ 136091d81d1SSam Leffler m = m_getptr(m, crd->crd_skip, &k); 137091d81d1SSam Leffler if (m == NULL) 138091d81d1SSam Leffler return EINVAL; 139091d81d1SSam Leffler 140091d81d1SSam Leffler i = crd->crd_len; 141091d81d1SSam Leffler 142091d81d1SSam Leffler while (i > 0) { 143091d81d1SSam Leffler /* 144091d81d1SSam Leffler * If there's insufficient data at the end of 145091d81d1SSam Leffler * an mbuf, we have to do some copying. 146091d81d1SSam Leffler */ 147091d81d1SSam Leffler if (m->m_len < k + blks && m->m_len != k) { 148091d81d1SSam Leffler m_copydata(m, k, blks, blk); 149091d81d1SSam Leffler 150091d81d1SSam Leffler /* Actual encryption/decryption */ 151d295bdeeSPawel Jakub Dawidek if (exf->reinit) { 152091d81d1SSam Leffler if (crd->crd_flags & CRD_F_ENCRYPT) { 153d295bdeeSPawel Jakub Dawidek exf->encrypt(sw->sw_kschedule, 154d295bdeeSPawel Jakub Dawidek blk); 155d295bdeeSPawel Jakub Dawidek } else { 156d295bdeeSPawel Jakub Dawidek exf->decrypt(sw->sw_kschedule, 157d295bdeeSPawel Jakub Dawidek blk); 158d295bdeeSPawel Jakub Dawidek } 159d295bdeeSPawel Jakub Dawidek } else if (crd->crd_flags & CRD_F_ENCRYPT) { 160091d81d1SSam Leffler /* XOR with previous block */ 161091d81d1SSam Leffler for (j = 0; j < blks; j++) 162091d81d1SSam Leffler blk[j] ^= ivp[j]; 163091d81d1SSam Leffler 164091d81d1SSam Leffler exf->encrypt(sw->sw_kschedule, blk); 165091d81d1SSam Leffler 166091d81d1SSam Leffler /* 167091d81d1SSam Leffler * Keep encrypted block for XOR'ing 168091d81d1SSam Leffler * with next block 169091d81d1SSam Leffler */ 170091d81d1SSam Leffler bcopy(blk, iv, blks); 171091d81d1SSam Leffler ivp = iv; 172091d81d1SSam Leffler } else { /* decrypt */ 173091d81d1SSam Leffler /* 174091d81d1SSam Leffler * Keep encrypted block for XOR'ing 175091d81d1SSam Leffler * with next block 176091d81d1SSam Leffler */ 177091d81d1SSam Leffler if (ivp == iv) 178091d81d1SSam Leffler bcopy(blk, piv, blks); 179091d81d1SSam Leffler else 180091d81d1SSam Leffler bcopy(blk, iv, blks); 181091d81d1SSam Leffler 182091d81d1SSam Leffler exf->decrypt(sw->sw_kschedule, blk); 183091d81d1SSam Leffler 184091d81d1SSam Leffler /* XOR with previous block */ 185091d81d1SSam Leffler for (j = 0; j < blks; j++) 186091d81d1SSam Leffler blk[j] ^= ivp[j]; 187091d81d1SSam Leffler 188091d81d1SSam Leffler if (ivp == iv) 189091d81d1SSam Leffler bcopy(piv, iv, blks); 190091d81d1SSam Leffler else 191091d81d1SSam Leffler ivp = iv; 192091d81d1SSam Leffler } 193091d81d1SSam Leffler 194091d81d1SSam Leffler /* Copy back decrypted block */ 195091d81d1SSam Leffler m_copyback(m, k, blks, blk); 196091d81d1SSam Leffler 197091d81d1SSam Leffler /* Advance pointer */ 198091d81d1SSam Leffler m = m_getptr(m, k + blks, &k); 199091d81d1SSam Leffler if (m == NULL) 200091d81d1SSam Leffler return EINVAL; 201091d81d1SSam Leffler 202091d81d1SSam Leffler i -= blks; 203091d81d1SSam Leffler 204091d81d1SSam Leffler /* Could be done... */ 205091d81d1SSam Leffler if (i == 0) 206091d81d1SSam Leffler break; 207091d81d1SSam Leffler } 208091d81d1SSam Leffler 209091d81d1SSam Leffler /* Skip possibly empty mbufs */ 210091d81d1SSam Leffler if (k == m->m_len) { 211091d81d1SSam Leffler for (m = m->m_next; m && m->m_len == 0; 212091d81d1SSam Leffler m = m->m_next) 213091d81d1SSam Leffler ; 214091d81d1SSam Leffler k = 0; 215091d81d1SSam Leffler } 216091d81d1SSam Leffler 217091d81d1SSam Leffler /* Sanity check */ 218091d81d1SSam Leffler if (m == NULL) 219091d81d1SSam Leffler return EINVAL; 220091d81d1SSam Leffler 221091d81d1SSam Leffler /* 222091d81d1SSam Leffler * Warning: idat may point to garbage here, but 223091d81d1SSam Leffler * we only use it in the while() loop, only if 224091d81d1SSam Leffler * there are indeed enough data. 225091d81d1SSam Leffler */ 226091d81d1SSam Leffler idat = mtod(m, unsigned char *) + k; 227091d81d1SSam Leffler 228091d81d1SSam Leffler while (m->m_len >= k + blks && i > 0) { 229d295bdeeSPawel Jakub Dawidek if (exf->reinit) { 230091d81d1SSam Leffler if (crd->crd_flags & CRD_F_ENCRYPT) { 231d295bdeeSPawel Jakub Dawidek exf->encrypt(sw->sw_kschedule, 232d295bdeeSPawel Jakub Dawidek idat); 233d295bdeeSPawel Jakub Dawidek } else { 234d295bdeeSPawel Jakub Dawidek exf->decrypt(sw->sw_kschedule, 235d295bdeeSPawel Jakub Dawidek idat); 236d295bdeeSPawel Jakub Dawidek } 237d295bdeeSPawel Jakub Dawidek } else if (crd->crd_flags & CRD_F_ENCRYPT) { 238091d81d1SSam Leffler /* XOR with previous block/IV */ 239091d81d1SSam Leffler for (j = 0; j < blks; j++) 240091d81d1SSam Leffler idat[j] ^= ivp[j]; 241091d81d1SSam Leffler 242091d81d1SSam Leffler exf->encrypt(sw->sw_kschedule, idat); 243091d81d1SSam Leffler ivp = idat; 244091d81d1SSam Leffler } else { /* decrypt */ 245091d81d1SSam Leffler /* 246091d81d1SSam Leffler * Keep encrypted block to be used 247091d81d1SSam Leffler * in next block's processing. 248091d81d1SSam Leffler */ 249091d81d1SSam Leffler if (ivp == iv) 250091d81d1SSam Leffler bcopy(idat, piv, blks); 251091d81d1SSam Leffler else 252091d81d1SSam Leffler bcopy(idat, iv, blks); 253091d81d1SSam Leffler 254091d81d1SSam Leffler exf->decrypt(sw->sw_kschedule, idat); 255091d81d1SSam Leffler 256091d81d1SSam Leffler /* XOR with previous block/IV */ 257091d81d1SSam Leffler for (j = 0; j < blks; j++) 258091d81d1SSam Leffler idat[j] ^= ivp[j]; 259091d81d1SSam Leffler 260091d81d1SSam Leffler if (ivp == iv) 261091d81d1SSam Leffler bcopy(piv, iv, blks); 262091d81d1SSam Leffler else 263091d81d1SSam Leffler ivp = iv; 264091d81d1SSam Leffler } 265091d81d1SSam Leffler 266091d81d1SSam Leffler idat += blks; 267091d81d1SSam Leffler k += blks; 268091d81d1SSam Leffler i -= blks; 269091d81d1SSam Leffler } 270091d81d1SSam Leffler } 271091d81d1SSam Leffler 272091d81d1SSam Leffler return 0; /* Done with mbuf encryption/decryption */ 273f34a967bSPawel Jakub Dawidek } else if (flags & CRYPTO_F_IOV) { 274091d81d1SSam Leffler struct uio *uio = (struct uio *) buf; 275091d81d1SSam Leffler struct iovec *iov; 276091d81d1SSam Leffler 277091d81d1SSam Leffler /* Find beginning of data */ 278091d81d1SSam Leffler iov = cuio_getptr(uio, crd->crd_skip, &k); 279091d81d1SSam Leffler if (iov == NULL) 280091d81d1SSam Leffler return EINVAL; 281091d81d1SSam Leffler 282091d81d1SSam Leffler i = crd->crd_len; 283091d81d1SSam Leffler 284091d81d1SSam Leffler while (i > 0) { 285091d81d1SSam Leffler /* 286091d81d1SSam Leffler * If there's insufficient data at the end of 287091d81d1SSam Leffler * an iovec, we have to do some copying. 288091d81d1SSam Leffler */ 289091d81d1SSam Leffler if (iov->iov_len < k + blks && iov->iov_len != k) { 290091d81d1SSam Leffler cuio_copydata(uio, k, blks, blk); 291091d81d1SSam Leffler 292091d81d1SSam Leffler /* Actual encryption/decryption */ 293d295bdeeSPawel Jakub Dawidek if (exf->reinit) { 294091d81d1SSam Leffler if (crd->crd_flags & CRD_F_ENCRYPT) { 295d295bdeeSPawel Jakub Dawidek exf->encrypt(sw->sw_kschedule, 296d295bdeeSPawel Jakub Dawidek blk); 297d295bdeeSPawel Jakub Dawidek } else { 298d295bdeeSPawel Jakub Dawidek exf->decrypt(sw->sw_kschedule, 299d295bdeeSPawel Jakub Dawidek blk); 300d295bdeeSPawel Jakub Dawidek } 301d295bdeeSPawel Jakub Dawidek } else if (crd->crd_flags & CRD_F_ENCRYPT) { 302091d81d1SSam Leffler /* XOR with previous block */ 303091d81d1SSam Leffler for (j = 0; j < blks; j++) 304091d81d1SSam Leffler blk[j] ^= ivp[j]; 305091d81d1SSam Leffler 306091d81d1SSam Leffler exf->encrypt(sw->sw_kschedule, blk); 307091d81d1SSam Leffler 308091d81d1SSam Leffler /* 309091d81d1SSam Leffler * Keep encrypted block for XOR'ing 310091d81d1SSam Leffler * with next block 311091d81d1SSam Leffler */ 312091d81d1SSam Leffler bcopy(blk, iv, blks); 313091d81d1SSam Leffler ivp = iv; 314091d81d1SSam Leffler } else { /* decrypt */ 315091d81d1SSam Leffler /* 316091d81d1SSam Leffler * Keep encrypted block for XOR'ing 317091d81d1SSam Leffler * with next block 318091d81d1SSam Leffler */ 319091d81d1SSam Leffler if (ivp == iv) 320091d81d1SSam Leffler bcopy(blk, piv, blks); 321091d81d1SSam Leffler else 322091d81d1SSam Leffler bcopy(blk, iv, blks); 323091d81d1SSam Leffler 324091d81d1SSam Leffler exf->decrypt(sw->sw_kschedule, blk); 325091d81d1SSam Leffler 326091d81d1SSam Leffler /* XOR with previous block */ 327091d81d1SSam Leffler for (j = 0; j < blks; j++) 328091d81d1SSam Leffler blk[j] ^= ivp[j]; 329091d81d1SSam Leffler 330091d81d1SSam Leffler if (ivp == iv) 331091d81d1SSam Leffler bcopy(piv, iv, blks); 332091d81d1SSam Leffler else 333091d81d1SSam Leffler ivp = iv; 334091d81d1SSam Leffler } 335091d81d1SSam Leffler 336091d81d1SSam Leffler /* Copy back decrypted block */ 337091d81d1SSam Leffler cuio_copyback(uio, k, blks, blk); 338091d81d1SSam Leffler 339091d81d1SSam Leffler /* Advance pointer */ 340091d81d1SSam Leffler iov = cuio_getptr(uio, k + blks, &k); 341091d81d1SSam Leffler if (iov == NULL) 342091d81d1SSam Leffler return EINVAL; 343091d81d1SSam Leffler 344091d81d1SSam Leffler i -= blks; 345091d81d1SSam Leffler 346091d81d1SSam Leffler /* Could be done... */ 347091d81d1SSam Leffler if (i == 0) 348091d81d1SSam Leffler break; 349091d81d1SSam Leffler } 350091d81d1SSam Leffler 351091d81d1SSam Leffler /* 352091d81d1SSam Leffler * Warning: idat may point to garbage here, but 353091d81d1SSam Leffler * we only use it in the while() loop, only if 354091d81d1SSam Leffler * there are indeed enough data. 355091d81d1SSam Leffler */ 3562b7f24d2SMike Barcroft idat = (char *)iov->iov_base + k; 357091d81d1SSam Leffler 358091d81d1SSam Leffler while (iov->iov_len >= k + blks && i > 0) { 359d295bdeeSPawel Jakub Dawidek if (exf->reinit) { 360091d81d1SSam Leffler if (crd->crd_flags & CRD_F_ENCRYPT) { 361d295bdeeSPawel Jakub Dawidek exf->encrypt(sw->sw_kschedule, 362d295bdeeSPawel Jakub Dawidek idat); 363d295bdeeSPawel Jakub Dawidek } else { 364d295bdeeSPawel Jakub Dawidek exf->decrypt(sw->sw_kschedule, 365d295bdeeSPawel Jakub Dawidek idat); 366d295bdeeSPawel Jakub Dawidek } 367d295bdeeSPawel Jakub Dawidek } else if (crd->crd_flags & CRD_F_ENCRYPT) { 368091d81d1SSam Leffler /* XOR with previous block/IV */ 369091d81d1SSam Leffler for (j = 0; j < blks; j++) 370091d81d1SSam Leffler idat[j] ^= ivp[j]; 371091d81d1SSam Leffler 372091d81d1SSam Leffler exf->encrypt(sw->sw_kschedule, idat); 373091d81d1SSam Leffler ivp = idat; 374091d81d1SSam Leffler } else { /* decrypt */ 375091d81d1SSam Leffler /* 376091d81d1SSam Leffler * Keep encrypted block to be used 377091d81d1SSam Leffler * in next block's processing. 378091d81d1SSam Leffler */ 379091d81d1SSam Leffler if (ivp == iv) 380091d81d1SSam Leffler bcopy(idat, piv, blks); 381091d81d1SSam Leffler else 382091d81d1SSam Leffler bcopy(idat, iv, blks); 383091d81d1SSam Leffler 384091d81d1SSam Leffler exf->decrypt(sw->sw_kschedule, idat); 385091d81d1SSam Leffler 386091d81d1SSam Leffler /* XOR with previous block/IV */ 387091d81d1SSam Leffler for (j = 0; j < blks; j++) 388091d81d1SSam Leffler idat[j] ^= ivp[j]; 389091d81d1SSam Leffler 390091d81d1SSam Leffler if (ivp == iv) 391091d81d1SSam Leffler bcopy(piv, iv, blks); 392091d81d1SSam Leffler else 393091d81d1SSam Leffler ivp = iv; 394091d81d1SSam Leffler } 395091d81d1SSam Leffler 396091d81d1SSam Leffler idat += blks; 397091d81d1SSam Leffler k += blks; 398091d81d1SSam Leffler i -= blks; 399091d81d1SSam Leffler } 400bfd50e27SDoug Rabson if (k == iov->iov_len) { 401bfd50e27SDoug Rabson iov++; 402bfd50e27SDoug Rabson k = 0; 403bfd50e27SDoug Rabson } 404091d81d1SSam Leffler } 405091d81d1SSam Leffler 406f6c4bc3bSPawel Jakub Dawidek return 0; /* Done with iovec encryption/decryption */ 407f34a967bSPawel Jakub Dawidek } else { /* contiguous buffer */ 408d295bdeeSPawel Jakub Dawidek if (exf->reinit) { 409d295bdeeSPawel Jakub Dawidek for (i = crd->crd_skip; 410d295bdeeSPawel Jakub Dawidek i < crd->crd_skip + crd->crd_len; i += blks) { 411d295bdeeSPawel Jakub Dawidek if (crd->crd_flags & CRD_F_ENCRYPT) 412d295bdeeSPawel Jakub Dawidek exf->encrypt(sw->sw_kschedule, buf + i); 413d295bdeeSPawel Jakub Dawidek else 414d295bdeeSPawel Jakub Dawidek exf->decrypt(sw->sw_kschedule, buf + i); 415d295bdeeSPawel Jakub Dawidek } 416d295bdeeSPawel Jakub Dawidek } else if (crd->crd_flags & CRD_F_ENCRYPT) { 417f34a967bSPawel Jakub Dawidek for (i = crd->crd_skip; 418f34a967bSPawel Jakub Dawidek i < crd->crd_skip + crd->crd_len; i += blks) { 419f34a967bSPawel Jakub Dawidek /* XOR with the IV/previous block, as appropriate. */ 420f34a967bSPawel Jakub Dawidek if (i == crd->crd_skip) 421f34a967bSPawel Jakub Dawidek for (k = 0; k < blks; k++) 422f34a967bSPawel Jakub Dawidek buf[i + k] ^= ivp[k]; 423f34a967bSPawel Jakub Dawidek else 424f34a967bSPawel Jakub Dawidek for (k = 0; k < blks; k++) 425f34a967bSPawel Jakub Dawidek buf[i + k] ^= buf[i + k - blks]; 426f34a967bSPawel Jakub Dawidek exf->encrypt(sw->sw_kschedule, buf + i); 427f34a967bSPawel Jakub Dawidek } 428f34a967bSPawel Jakub Dawidek } else { /* Decrypt */ 429f34a967bSPawel Jakub Dawidek /* 430f34a967bSPawel Jakub Dawidek * Start at the end, so we don't need to keep the encrypted 431f34a967bSPawel Jakub Dawidek * block as the IV for the next block. 432f34a967bSPawel Jakub Dawidek */ 433f34a967bSPawel Jakub Dawidek for (i = crd->crd_skip + crd->crd_len - blks; 434f34a967bSPawel Jakub Dawidek i >= crd->crd_skip; i -= blks) { 435f34a967bSPawel Jakub Dawidek exf->decrypt(sw->sw_kschedule, buf + i); 436f34a967bSPawel Jakub Dawidek 437f34a967bSPawel Jakub Dawidek /* XOR with the IV/previous block, as appropriate */ 438f34a967bSPawel Jakub Dawidek if (i == crd->crd_skip) 439f34a967bSPawel Jakub Dawidek for (k = 0; k < blks; k++) 440f34a967bSPawel Jakub Dawidek buf[i + k] ^= ivp[k]; 441f34a967bSPawel Jakub Dawidek else 442f34a967bSPawel Jakub Dawidek for (k = 0; k < blks; k++) 443f34a967bSPawel Jakub Dawidek buf[i + k] ^= buf[i + k - blks]; 444f34a967bSPawel Jakub Dawidek } 445f34a967bSPawel Jakub Dawidek } 446f34a967bSPawel Jakub Dawidek 447f34a967bSPawel Jakub Dawidek return 0; /* Done with contiguous buffer encryption/decryption */ 448091d81d1SSam Leffler } 449091d81d1SSam Leffler 450091d81d1SSam Leffler /* Unreachable */ 451091d81d1SSam Leffler return EINVAL; 452091d81d1SSam Leffler } 453091d81d1SSam Leffler 454f6c4bc3bSPawel Jakub Dawidek static void 455f6c4bc3bSPawel Jakub Dawidek swcr_authprepare(struct auth_hash *axf, struct swcr_data *sw, u_char *key, 456f6c4bc3bSPawel Jakub Dawidek int klen) 457f6c4bc3bSPawel Jakub Dawidek { 458f6c4bc3bSPawel Jakub Dawidek int k; 459f6c4bc3bSPawel Jakub Dawidek 460f6c4bc3bSPawel Jakub Dawidek klen /= 8; 461f6c4bc3bSPawel Jakub Dawidek 462f6c4bc3bSPawel Jakub Dawidek switch (axf->type) { 463f6c4bc3bSPawel Jakub Dawidek case CRYPTO_MD5_HMAC: 464f6c4bc3bSPawel Jakub Dawidek case CRYPTO_SHA1_HMAC: 465f6c4bc3bSPawel Jakub Dawidek case CRYPTO_SHA2_256_HMAC: 466f6c4bc3bSPawel Jakub Dawidek case CRYPTO_SHA2_384_HMAC: 467f6c4bc3bSPawel Jakub Dawidek case CRYPTO_SHA2_512_HMAC: 468f6c4bc3bSPawel Jakub Dawidek case CRYPTO_NULL_HMAC: 469f6c4bc3bSPawel Jakub Dawidek case CRYPTO_RIPEMD160_HMAC: 470f6c4bc3bSPawel Jakub Dawidek for (k = 0; k < klen; k++) 471f6c4bc3bSPawel Jakub Dawidek key[k] ^= HMAC_IPAD_VAL; 472f6c4bc3bSPawel Jakub Dawidek 473f6c4bc3bSPawel Jakub Dawidek axf->Init(sw->sw_ictx); 474f6c4bc3bSPawel Jakub Dawidek axf->Update(sw->sw_ictx, key, klen); 475f6c4bc3bSPawel Jakub Dawidek axf->Update(sw->sw_ictx, hmac_ipad_buffer, axf->blocksize - klen); 476f6c4bc3bSPawel Jakub Dawidek 477f6c4bc3bSPawel Jakub Dawidek for (k = 0; k < klen; k++) 478f6c4bc3bSPawel Jakub Dawidek key[k] ^= (HMAC_IPAD_VAL ^ HMAC_OPAD_VAL); 479f6c4bc3bSPawel Jakub Dawidek 480f6c4bc3bSPawel Jakub Dawidek axf->Init(sw->sw_octx); 481f6c4bc3bSPawel Jakub Dawidek axf->Update(sw->sw_octx, key, klen); 482f6c4bc3bSPawel Jakub Dawidek axf->Update(sw->sw_octx, hmac_opad_buffer, axf->blocksize - klen); 483f6c4bc3bSPawel Jakub Dawidek 484f6c4bc3bSPawel Jakub Dawidek for (k = 0; k < klen; k++) 485f6c4bc3bSPawel Jakub Dawidek key[k] ^= HMAC_OPAD_VAL; 486f6c4bc3bSPawel Jakub Dawidek break; 487f6c4bc3bSPawel Jakub Dawidek case CRYPTO_MD5_KPDK: 488f6c4bc3bSPawel Jakub Dawidek case CRYPTO_SHA1_KPDK: 4891f4990a6SBjoern A. Zeeb { 49077680d96SBjoern A. Zeeb /* 49177680d96SBjoern A. Zeeb * We need a buffer that can hold an md5 and a sha1 result 49277680d96SBjoern A. Zeeb * just to throw it away. 49377680d96SBjoern A. Zeeb * What we do here is the initial part of: 49477680d96SBjoern A. Zeeb * ALGO( key, keyfill, .. ) 49577680d96SBjoern A. Zeeb * adding the key to sw_ictx and abusing Final() to get the 49677680d96SBjoern A. Zeeb * "keyfill" padding. 49777680d96SBjoern A. Zeeb * In addition we abuse the sw_octx to save the key to have 49877680d96SBjoern A. Zeeb * it to be able to append it at the end in swcr_authcompute(). 49977680d96SBjoern A. Zeeb */ 5001f4990a6SBjoern A. Zeeb u_char buf[SHA1_RESULTLEN]; 5011f4990a6SBjoern A. Zeeb 502f6c4bc3bSPawel Jakub Dawidek sw->sw_klen = klen; 503f6c4bc3bSPawel Jakub Dawidek bcopy(key, sw->sw_octx, klen); 504f6c4bc3bSPawel Jakub Dawidek axf->Init(sw->sw_ictx); 505f6c4bc3bSPawel Jakub Dawidek axf->Update(sw->sw_ictx, key, klen); 5061f4990a6SBjoern A. Zeeb axf->Final(buf, sw->sw_ictx); 507f6c4bc3bSPawel Jakub Dawidek break; 5081f4990a6SBjoern A. Zeeb } 509f6c4bc3bSPawel Jakub Dawidek default: 510f6c4bc3bSPawel Jakub Dawidek printf("%s: CRD_F_KEY_EXPLICIT flag given, but algorithm %d " 511f6c4bc3bSPawel Jakub Dawidek "doesn't use keys.\n", __func__, axf->type); 512f6c4bc3bSPawel Jakub Dawidek } 513f6c4bc3bSPawel Jakub Dawidek } 514f6c4bc3bSPawel Jakub Dawidek 515091d81d1SSam Leffler /* 516091d81d1SSam Leffler * Compute keyed-hash authenticator. 517091d81d1SSam Leffler */ 518091d81d1SSam Leffler static int 51938d2f8d6SPawel Jakub Dawidek swcr_authcompute(struct cryptodesc *crd, struct swcr_data *sw, caddr_t buf, 520f34a967bSPawel Jakub Dawidek int flags) 521091d81d1SSam Leffler { 5220bbc4bf9SPawel Jakub Dawidek unsigned char aalg[HASH_MAX_LEN]; 523091d81d1SSam Leffler struct auth_hash *axf; 524091d81d1SSam Leffler union authctx ctx; 525091d81d1SSam Leffler int err; 526091d81d1SSam Leffler 527091d81d1SSam Leffler if (sw->sw_ictx == 0) 528091d81d1SSam Leffler return EINVAL; 529091d81d1SSam Leffler 530091d81d1SSam Leffler axf = sw->sw_axf; 531091d81d1SSam Leffler 532f6c4bc3bSPawel Jakub Dawidek if (crd->crd_flags & CRD_F_KEY_EXPLICIT) 533f6c4bc3bSPawel Jakub Dawidek swcr_authprepare(axf, sw, crd->crd_key, crd->crd_klen); 534f6c4bc3bSPawel Jakub Dawidek 535091d81d1SSam Leffler bcopy(sw->sw_ictx, &ctx, axf->ctxsize); 536091d81d1SSam Leffler 537f34a967bSPawel Jakub Dawidek err = crypto_apply(flags, buf, crd->crd_skip, crd->crd_len, 538f34a967bSPawel Jakub Dawidek (int (*)(void *, void *, unsigned int))axf->Update, (caddr_t)&ctx); 539091d81d1SSam Leffler if (err) 540091d81d1SSam Leffler return err; 541091d81d1SSam Leffler 542091d81d1SSam Leffler switch (sw->sw_alg) { 543091d81d1SSam Leffler case CRYPTO_MD5_HMAC: 544091d81d1SSam Leffler case CRYPTO_SHA1_HMAC: 545f6c4bc3bSPawel Jakub Dawidek case CRYPTO_SHA2_256_HMAC: 546f6c4bc3bSPawel Jakub Dawidek case CRYPTO_SHA2_384_HMAC: 547f6c4bc3bSPawel Jakub Dawidek case CRYPTO_SHA2_512_HMAC: 548091d81d1SSam Leffler case CRYPTO_RIPEMD160_HMAC: 549091d81d1SSam Leffler if (sw->sw_octx == NULL) 550091d81d1SSam Leffler return EINVAL; 551091d81d1SSam Leffler 552091d81d1SSam Leffler axf->Final(aalg, &ctx); 553091d81d1SSam Leffler bcopy(sw->sw_octx, &ctx, axf->ctxsize); 554091d81d1SSam Leffler axf->Update(&ctx, aalg, axf->hashsize); 555091d81d1SSam Leffler axf->Final(aalg, &ctx); 556091d81d1SSam Leffler break; 557091d81d1SSam Leffler 558091d81d1SSam Leffler case CRYPTO_MD5_KPDK: 559091d81d1SSam Leffler case CRYPTO_SHA1_KPDK: 56077680d96SBjoern A. Zeeb /* If we have no key saved, return error. */ 561091d81d1SSam Leffler if (sw->sw_octx == NULL) 562091d81d1SSam Leffler return EINVAL; 563091d81d1SSam Leffler 56477680d96SBjoern A. Zeeb /* 56577680d96SBjoern A. Zeeb * Add the trailing copy of the key (see comment in 56677680d96SBjoern A. Zeeb * swcr_authprepare()) after the data: 56777680d96SBjoern A. Zeeb * ALGO( .., key, algofill ) 56877680d96SBjoern A. Zeeb * and let Final() do the proper, natural "algofill" 56977680d96SBjoern A. Zeeb * padding. 57077680d96SBjoern A. Zeeb */ 571091d81d1SSam Leffler axf->Update(&ctx, sw->sw_octx, sw->sw_klen); 572091d81d1SSam Leffler axf->Final(aalg, &ctx); 573091d81d1SSam Leffler break; 574091d81d1SSam Leffler 575091d81d1SSam Leffler case CRYPTO_NULL_HMAC: 576091d81d1SSam Leffler axf->Final(aalg, &ctx); 577091d81d1SSam Leffler break; 578091d81d1SSam Leffler } 579091d81d1SSam Leffler 580091d81d1SSam Leffler /* Inject the authentication data */ 581f34a967bSPawel Jakub Dawidek crypto_copyback(flags, buf, crd->crd_inject, 582f6c4bc3bSPawel Jakub Dawidek sw->sw_mlen == 0 ? axf->hashsize : sw->sw_mlen, aalg); 583091d81d1SSam Leffler return 0; 584091d81d1SSam Leffler } 585091d81d1SSam Leffler 586091d81d1SSam Leffler /* 587091d81d1SSam Leffler * Apply a compression/decompression algorithm 588091d81d1SSam Leffler */ 589091d81d1SSam Leffler static int 590091d81d1SSam Leffler swcr_compdec(struct cryptodesc *crd, struct swcr_data *sw, 591f34a967bSPawel Jakub Dawidek caddr_t buf, int flags) 592091d81d1SSam Leffler { 593091d81d1SSam Leffler u_int8_t *data, *out; 594091d81d1SSam Leffler struct comp_algo *cxf; 595091d81d1SSam Leffler int adj; 596091d81d1SSam Leffler u_int32_t result; 597091d81d1SSam Leffler 598091d81d1SSam Leffler cxf = sw->sw_cxf; 599091d81d1SSam Leffler 600091d81d1SSam Leffler /* We must handle the whole buffer of data in one time 601091d81d1SSam Leffler * then if there is not all the data in the mbuf, we must 602091d81d1SSam Leffler * copy in a buffer. 603091d81d1SSam Leffler */ 604091d81d1SSam Leffler 6051ede983cSDag-Erling Smørgrav data = malloc(crd->crd_len, M_CRYPTO_DATA, M_NOWAIT); 606091d81d1SSam Leffler if (data == NULL) 607091d81d1SSam Leffler return (EINVAL); 608f34a967bSPawel Jakub Dawidek crypto_copydata(flags, buf, crd->crd_skip, crd->crd_len, data); 609091d81d1SSam Leffler 610091d81d1SSam Leffler if (crd->crd_flags & CRD_F_COMP) 611091d81d1SSam Leffler result = cxf->compress(data, crd->crd_len, &out); 612091d81d1SSam Leffler else 613091d81d1SSam Leffler result = cxf->decompress(data, crd->crd_len, &out); 614091d81d1SSam Leffler 6151ede983cSDag-Erling Smørgrav free(data, M_CRYPTO_DATA); 616091d81d1SSam Leffler if (result == 0) 617091d81d1SSam Leffler return EINVAL; 618091d81d1SSam Leffler 619091d81d1SSam Leffler /* Copy back the (de)compressed data. m_copyback is 620091d81d1SSam Leffler * extending the mbuf as necessary. 621091d81d1SSam Leffler */ 622091d81d1SSam Leffler sw->sw_size = result; 623091d81d1SSam Leffler /* Check the compressed size when doing compression */ 624091d81d1SSam Leffler if (crd->crd_flags & CRD_F_COMP) { 625df4dece1SBjoern A. Zeeb if (result >= crd->crd_len) { 626091d81d1SSam Leffler /* Compression was useless, we lost time */ 6271ede983cSDag-Erling Smørgrav free(out, M_CRYPTO_DATA); 628091d81d1SSam Leffler return 0; 629091d81d1SSam Leffler } 630091d81d1SSam Leffler } 631091d81d1SSam Leffler 632f34a967bSPawel Jakub Dawidek crypto_copyback(flags, buf, crd->crd_skip, result, out); 633091d81d1SSam Leffler if (result < crd->crd_len) { 634091d81d1SSam Leffler adj = result - crd->crd_len; 635f34a967bSPawel Jakub Dawidek if (flags & CRYPTO_F_IMBUF) { 636091d81d1SSam Leffler adj = result - crd->crd_len; 637091d81d1SSam Leffler m_adj((struct mbuf *)buf, adj); 638f34a967bSPawel Jakub Dawidek } else if (flags & CRYPTO_F_IOV) { 639091d81d1SSam Leffler struct uio *uio = (struct uio *)buf; 640091d81d1SSam Leffler int ind; 641091d81d1SSam Leffler 642091d81d1SSam Leffler adj = crd->crd_len - result; 643091d81d1SSam Leffler ind = uio->uio_iovcnt - 1; 644091d81d1SSam Leffler 645091d81d1SSam Leffler while (adj > 0 && ind >= 0) { 646091d81d1SSam Leffler if (adj < uio->uio_iov[ind].iov_len) { 647091d81d1SSam Leffler uio->uio_iov[ind].iov_len -= adj; 648091d81d1SSam Leffler break; 649091d81d1SSam Leffler } 650091d81d1SSam Leffler 651091d81d1SSam Leffler adj -= uio->uio_iov[ind].iov_len; 652091d81d1SSam Leffler uio->uio_iov[ind].iov_len = 0; 653091d81d1SSam Leffler ind--; 654091d81d1SSam Leffler uio->uio_iovcnt--; 655091d81d1SSam Leffler } 656091d81d1SSam Leffler } 657091d81d1SSam Leffler } 6581ede983cSDag-Erling Smørgrav free(out, M_CRYPTO_DATA); 659091d81d1SSam Leffler return 0; 660091d81d1SSam Leffler } 661091d81d1SSam Leffler 662091d81d1SSam Leffler /* 663091d81d1SSam Leffler * Generate a new software session. 664091d81d1SSam Leffler */ 665091d81d1SSam Leffler static int 6666810ad6fSSam Leffler swcr_newsession(device_t dev, u_int32_t *sid, struct cryptoini *cri) 667091d81d1SSam Leffler { 668091d81d1SSam Leffler struct swcr_data **swd; 669091d81d1SSam Leffler struct auth_hash *axf; 670091d81d1SSam Leffler struct enc_xform *txf; 671091d81d1SSam Leffler struct comp_algo *cxf; 672091d81d1SSam Leffler u_int32_t i; 673f6c4bc3bSPawel Jakub Dawidek int error; 674091d81d1SSam Leffler 675091d81d1SSam Leffler if (sid == NULL || cri == NULL) 676091d81d1SSam Leffler return EINVAL; 677091d81d1SSam Leffler 678109919c6SBenno Rice rw_wlock(&swcr_sessions_lock); 679091d81d1SSam Leffler if (swcr_sessions) { 680091d81d1SSam Leffler for (i = 1; i < swcr_sesnum; i++) 681091d81d1SSam Leffler if (swcr_sessions[i] == NULL) 682091d81d1SSam Leffler break; 683091d81d1SSam Leffler } else 684091d81d1SSam Leffler i = 1; /* NB: to silence compiler warning */ 685091d81d1SSam Leffler 686091d81d1SSam Leffler if (swcr_sessions == NULL || i == swcr_sesnum) { 687091d81d1SSam Leffler if (swcr_sessions == NULL) { 688091d81d1SSam Leffler i = 1; /* We leave swcr_sessions[0] empty */ 689091d81d1SSam Leffler swcr_sesnum = CRYPTO_SW_SESSIONS; 690091d81d1SSam Leffler } else 691091d81d1SSam Leffler swcr_sesnum *= 2; 692091d81d1SSam Leffler 693091d81d1SSam Leffler swd = malloc(swcr_sesnum * sizeof(struct swcr_data *), 694091d81d1SSam Leffler M_CRYPTO_DATA, M_NOWAIT|M_ZERO); 695091d81d1SSam Leffler if (swd == NULL) { 696091d81d1SSam Leffler /* Reset session number */ 697091d81d1SSam Leffler if (swcr_sesnum == CRYPTO_SW_SESSIONS) 698091d81d1SSam Leffler swcr_sesnum = 0; 699091d81d1SSam Leffler else 700091d81d1SSam Leffler swcr_sesnum /= 2; 701109919c6SBenno Rice rw_wunlock(&swcr_sessions_lock); 702091d81d1SSam Leffler return ENOBUFS; 703091d81d1SSam Leffler } 704091d81d1SSam Leffler 705091d81d1SSam Leffler /* Copy existing sessions */ 7066810ad6fSSam Leffler if (swcr_sessions != NULL) { 707091d81d1SSam Leffler bcopy(swcr_sessions, swd, 708091d81d1SSam Leffler (swcr_sesnum / 2) * sizeof(struct swcr_data *)); 709091d81d1SSam Leffler free(swcr_sessions, M_CRYPTO_DATA); 710091d81d1SSam Leffler } 711091d81d1SSam Leffler 712091d81d1SSam Leffler swcr_sessions = swd; 713091d81d1SSam Leffler } 714091d81d1SSam Leffler 715109919c6SBenno Rice rw_downgrade(&swcr_sessions_lock); 716091d81d1SSam Leffler swd = &swcr_sessions[i]; 717091d81d1SSam Leffler *sid = i; 718091d81d1SSam Leffler 719091d81d1SSam Leffler while (cri) { 7201ede983cSDag-Erling Smørgrav *swd = malloc(sizeof(struct swcr_data), 721091d81d1SSam Leffler M_CRYPTO_DATA, M_NOWAIT|M_ZERO); 722091d81d1SSam Leffler if (*swd == NULL) { 723109919c6SBenno Rice swcr_freesession_locked(dev, i); 724109919c6SBenno Rice rw_runlock(&swcr_sessions_lock); 725091d81d1SSam Leffler return ENOBUFS; 726091d81d1SSam Leffler } 727091d81d1SSam Leffler 728091d81d1SSam Leffler switch (cri->cri_alg) { 729091d81d1SSam Leffler case CRYPTO_DES_CBC: 730091d81d1SSam Leffler txf = &enc_xform_des; 731091d81d1SSam Leffler goto enccommon; 732091d81d1SSam Leffler case CRYPTO_3DES_CBC: 733091d81d1SSam Leffler txf = &enc_xform_3des; 734091d81d1SSam Leffler goto enccommon; 735091d81d1SSam Leffler case CRYPTO_BLF_CBC: 736091d81d1SSam Leffler txf = &enc_xform_blf; 737091d81d1SSam Leffler goto enccommon; 738091d81d1SSam Leffler case CRYPTO_CAST_CBC: 739091d81d1SSam Leffler txf = &enc_xform_cast5; 740091d81d1SSam Leffler goto enccommon; 741091d81d1SSam Leffler case CRYPTO_SKIPJACK_CBC: 742091d81d1SSam Leffler txf = &enc_xform_skipjack; 743091d81d1SSam Leffler goto enccommon; 744091d81d1SSam Leffler case CRYPTO_RIJNDAEL128_CBC: 745091d81d1SSam Leffler txf = &enc_xform_rijndael128; 746091d81d1SSam Leffler goto enccommon; 747d295bdeeSPawel Jakub Dawidek case CRYPTO_AES_XTS: 748d295bdeeSPawel Jakub Dawidek txf = &enc_xform_aes_xts; 749d295bdeeSPawel Jakub Dawidek goto enccommon; 750559d3390SGeorge V. Neville-Neil case CRYPTO_CAMELLIA_CBC: 751559d3390SGeorge V. Neville-Neil txf = &enc_xform_camellia; 752559d3390SGeorge V. Neville-Neil goto enccommon; 753091d81d1SSam Leffler case CRYPTO_NULL_CBC: 754091d81d1SSam Leffler txf = &enc_xform_null; 755091d81d1SSam Leffler goto enccommon; 756091d81d1SSam Leffler enccommon: 757f6c4bc3bSPawel Jakub Dawidek if (cri->cri_key != NULL) { 758091d81d1SSam Leffler error = txf->setkey(&((*swd)->sw_kschedule), 759091d81d1SSam Leffler cri->cri_key, cri->cri_klen / 8); 760091d81d1SSam Leffler if (error) { 761109919c6SBenno Rice swcr_freesession_locked(dev, i); 762109919c6SBenno Rice rw_runlock(&swcr_sessions_lock); 763091d81d1SSam Leffler return error; 764091d81d1SSam Leffler } 765f6c4bc3bSPawel Jakub Dawidek } 766091d81d1SSam Leffler (*swd)->sw_exf = txf; 767091d81d1SSam Leffler break; 768091d81d1SSam Leffler 769091d81d1SSam Leffler case CRYPTO_MD5_HMAC: 770f6c4bc3bSPawel Jakub Dawidek axf = &auth_hash_hmac_md5; 771091d81d1SSam Leffler goto authcommon; 772091d81d1SSam Leffler case CRYPTO_SHA1_HMAC: 773f6c4bc3bSPawel Jakub Dawidek axf = &auth_hash_hmac_sha1; 774091d81d1SSam Leffler goto authcommon; 775f6c4bc3bSPawel Jakub Dawidek case CRYPTO_SHA2_256_HMAC: 776091d81d1SSam Leffler axf = &auth_hash_hmac_sha2_256; 777f6c4bc3bSPawel Jakub Dawidek goto authcommon; 778f6c4bc3bSPawel Jakub Dawidek case CRYPTO_SHA2_384_HMAC: 779091d81d1SSam Leffler axf = &auth_hash_hmac_sha2_384; 780f6c4bc3bSPawel Jakub Dawidek goto authcommon; 781f6c4bc3bSPawel Jakub Dawidek case CRYPTO_SHA2_512_HMAC: 782091d81d1SSam Leffler axf = &auth_hash_hmac_sha2_512; 783091d81d1SSam Leffler goto authcommon; 784091d81d1SSam Leffler case CRYPTO_NULL_HMAC: 785091d81d1SSam Leffler axf = &auth_hash_null; 786091d81d1SSam Leffler goto authcommon; 787091d81d1SSam Leffler case CRYPTO_RIPEMD160_HMAC: 788f6c4bc3bSPawel Jakub Dawidek axf = &auth_hash_hmac_ripemd_160; 789091d81d1SSam Leffler authcommon: 790091d81d1SSam Leffler (*swd)->sw_ictx = malloc(axf->ctxsize, M_CRYPTO_DATA, 791091d81d1SSam Leffler M_NOWAIT); 792091d81d1SSam Leffler if ((*swd)->sw_ictx == NULL) { 793109919c6SBenno Rice swcr_freesession_locked(dev, i); 794109919c6SBenno Rice rw_runlock(&swcr_sessions_lock); 795091d81d1SSam Leffler return ENOBUFS; 796091d81d1SSam Leffler } 797091d81d1SSam Leffler 798091d81d1SSam Leffler (*swd)->sw_octx = malloc(axf->ctxsize, M_CRYPTO_DATA, 799091d81d1SSam Leffler M_NOWAIT); 800091d81d1SSam Leffler if ((*swd)->sw_octx == NULL) { 801109919c6SBenno Rice swcr_freesession_locked(dev, i); 802109919c6SBenno Rice rw_runlock(&swcr_sessions_lock); 803091d81d1SSam Leffler return ENOBUFS; 804091d81d1SSam Leffler } 805091d81d1SSam Leffler 806f6c4bc3bSPawel Jakub Dawidek if (cri->cri_key != NULL) { 807f6c4bc3bSPawel Jakub Dawidek swcr_authprepare(axf, *swd, cri->cri_key, 808f6c4bc3bSPawel Jakub Dawidek cri->cri_klen); 809f6c4bc3bSPawel Jakub Dawidek } 810091d81d1SSam Leffler 811f6c4bc3bSPawel Jakub Dawidek (*swd)->sw_mlen = cri->cri_mlen; 812091d81d1SSam Leffler (*swd)->sw_axf = axf; 813091d81d1SSam Leffler break; 814091d81d1SSam Leffler 815091d81d1SSam Leffler case CRYPTO_MD5_KPDK: 816091d81d1SSam Leffler axf = &auth_hash_key_md5; 817091d81d1SSam Leffler goto auth2common; 818091d81d1SSam Leffler 819091d81d1SSam Leffler case CRYPTO_SHA1_KPDK: 820091d81d1SSam Leffler axf = &auth_hash_key_sha1; 821091d81d1SSam Leffler auth2common: 822091d81d1SSam Leffler (*swd)->sw_ictx = malloc(axf->ctxsize, M_CRYPTO_DATA, 823091d81d1SSam Leffler M_NOWAIT); 824091d81d1SSam Leffler if ((*swd)->sw_ictx == NULL) { 825109919c6SBenno Rice swcr_freesession_locked(dev, i); 826109919c6SBenno Rice rw_runlock(&swcr_sessions_lock); 827091d81d1SSam Leffler return ENOBUFS; 828091d81d1SSam Leffler } 829091d81d1SSam Leffler 830f6c4bc3bSPawel Jakub Dawidek (*swd)->sw_octx = malloc(cri->cri_klen / 8, 831f6c4bc3bSPawel Jakub Dawidek M_CRYPTO_DATA, M_NOWAIT); 832091d81d1SSam Leffler if ((*swd)->sw_octx == NULL) { 833109919c6SBenno Rice swcr_freesession_locked(dev, i); 834109919c6SBenno Rice rw_runlock(&swcr_sessions_lock); 835091d81d1SSam Leffler return ENOBUFS; 836091d81d1SSam Leffler } 837091d81d1SSam Leffler 838f6c4bc3bSPawel Jakub Dawidek /* Store the key so we can "append" it to the payload */ 839f6c4bc3bSPawel Jakub Dawidek if (cri->cri_key != NULL) { 840f6c4bc3bSPawel Jakub Dawidek swcr_authprepare(axf, *swd, cri->cri_key, 841f6c4bc3bSPawel Jakub Dawidek cri->cri_klen); 842f6c4bc3bSPawel Jakub Dawidek } 843f6c4bc3bSPawel Jakub Dawidek 844f6c4bc3bSPawel Jakub Dawidek (*swd)->sw_mlen = cri->cri_mlen; 845091d81d1SSam Leffler (*swd)->sw_axf = axf; 846091d81d1SSam Leffler break; 847091d81d1SSam Leffler #ifdef notdef 848091d81d1SSam Leffler case CRYPTO_MD5: 849091d81d1SSam Leffler axf = &auth_hash_md5; 850091d81d1SSam Leffler goto auth3common; 851091d81d1SSam Leffler 852091d81d1SSam Leffler case CRYPTO_SHA1: 853091d81d1SSam Leffler axf = &auth_hash_sha1; 854091d81d1SSam Leffler auth3common: 855091d81d1SSam Leffler (*swd)->sw_ictx = malloc(axf->ctxsize, M_CRYPTO_DATA, 856091d81d1SSam Leffler M_NOWAIT); 857091d81d1SSam Leffler if ((*swd)->sw_ictx == NULL) { 858109919c6SBenno Rice swcr_freesession_locked(dev, i); 859109919c6SBenno Rice rw_runlock(&swcr_sessions_lock); 860091d81d1SSam Leffler return ENOBUFS; 861091d81d1SSam Leffler } 862091d81d1SSam Leffler 863091d81d1SSam Leffler axf->Init((*swd)->sw_ictx); 864f6c4bc3bSPawel Jakub Dawidek (*swd)->sw_mlen = cri->cri_mlen; 865091d81d1SSam Leffler (*swd)->sw_axf = axf; 866091d81d1SSam Leffler break; 867091d81d1SSam Leffler #endif 868091d81d1SSam Leffler case CRYPTO_DEFLATE_COMP: 869091d81d1SSam Leffler cxf = &comp_algo_deflate; 870091d81d1SSam Leffler (*swd)->sw_cxf = cxf; 871091d81d1SSam Leffler break; 872091d81d1SSam Leffler default: 873109919c6SBenno Rice swcr_freesession_locked(dev, i); 874109919c6SBenno Rice rw_runlock(&swcr_sessions_lock); 875091d81d1SSam Leffler return EINVAL; 876091d81d1SSam Leffler } 877091d81d1SSam Leffler 878091d81d1SSam Leffler (*swd)->sw_alg = cri->cri_alg; 879091d81d1SSam Leffler cri = cri->cri_next; 880091d81d1SSam Leffler swd = &((*swd)->sw_next); 881091d81d1SSam Leffler } 882109919c6SBenno Rice rw_runlock(&swcr_sessions_lock); 883091d81d1SSam Leffler return 0; 884091d81d1SSam Leffler } 885091d81d1SSam Leffler 886109919c6SBenno Rice static int 887109919c6SBenno Rice swcr_freesession(device_t dev, u_int64_t tid) 888109919c6SBenno Rice { 889109919c6SBenno Rice int error; 890109919c6SBenno Rice 891109919c6SBenno Rice rw_rlock(&swcr_sessions_lock); 892109919c6SBenno Rice error = swcr_freesession_locked(dev, tid); 893109919c6SBenno Rice rw_runlock(&swcr_sessions_lock); 894109919c6SBenno Rice return error; 895109919c6SBenno Rice } 896109919c6SBenno Rice 897091d81d1SSam Leffler /* 898091d81d1SSam Leffler * Free a session. 899091d81d1SSam Leffler */ 900091d81d1SSam Leffler static int 901109919c6SBenno Rice swcr_freesession_locked(device_t dev, u_int64_t tid) 902091d81d1SSam Leffler { 903091d81d1SSam Leffler struct swcr_data *swd; 904091d81d1SSam Leffler struct enc_xform *txf; 905091d81d1SSam Leffler struct auth_hash *axf; 906091d81d1SSam Leffler struct comp_algo *cxf; 90707d0c94aSSam Leffler u_int32_t sid = CRYPTO_SESID2LID(tid); 908091d81d1SSam Leffler 909091d81d1SSam Leffler if (sid > swcr_sesnum || swcr_sessions == NULL || 910091d81d1SSam Leffler swcr_sessions[sid] == NULL) 911091d81d1SSam Leffler return EINVAL; 912091d81d1SSam Leffler 913091d81d1SSam Leffler /* Silently accept and return */ 914091d81d1SSam Leffler if (sid == 0) 915091d81d1SSam Leffler return 0; 916091d81d1SSam Leffler 917091d81d1SSam Leffler while ((swd = swcr_sessions[sid]) != NULL) { 918091d81d1SSam Leffler swcr_sessions[sid] = swd->sw_next; 919091d81d1SSam Leffler 920091d81d1SSam Leffler switch (swd->sw_alg) { 921091d81d1SSam Leffler case CRYPTO_DES_CBC: 922091d81d1SSam Leffler case CRYPTO_3DES_CBC: 923091d81d1SSam Leffler case CRYPTO_BLF_CBC: 924091d81d1SSam Leffler case CRYPTO_CAST_CBC: 925091d81d1SSam Leffler case CRYPTO_SKIPJACK_CBC: 926091d81d1SSam Leffler case CRYPTO_RIJNDAEL128_CBC: 927d295bdeeSPawel Jakub Dawidek case CRYPTO_AES_XTS: 928559d3390SGeorge V. Neville-Neil case CRYPTO_CAMELLIA_CBC: 929091d81d1SSam Leffler case CRYPTO_NULL_CBC: 930091d81d1SSam Leffler txf = swd->sw_exf; 931091d81d1SSam Leffler 932091d81d1SSam Leffler if (swd->sw_kschedule) 933091d81d1SSam Leffler txf->zerokey(&(swd->sw_kschedule)); 934091d81d1SSam Leffler break; 935091d81d1SSam Leffler 936091d81d1SSam Leffler case CRYPTO_MD5_HMAC: 937091d81d1SSam Leffler case CRYPTO_SHA1_HMAC: 938f6c4bc3bSPawel Jakub Dawidek case CRYPTO_SHA2_256_HMAC: 939f6c4bc3bSPawel Jakub Dawidek case CRYPTO_SHA2_384_HMAC: 940f6c4bc3bSPawel Jakub Dawidek case CRYPTO_SHA2_512_HMAC: 941091d81d1SSam Leffler case CRYPTO_RIPEMD160_HMAC: 942091d81d1SSam Leffler case CRYPTO_NULL_HMAC: 943091d81d1SSam Leffler axf = swd->sw_axf; 944091d81d1SSam Leffler 945091d81d1SSam Leffler if (swd->sw_ictx) { 946091d81d1SSam Leffler bzero(swd->sw_ictx, axf->ctxsize); 947091d81d1SSam Leffler free(swd->sw_ictx, M_CRYPTO_DATA); 948091d81d1SSam Leffler } 949091d81d1SSam Leffler if (swd->sw_octx) { 950091d81d1SSam Leffler bzero(swd->sw_octx, axf->ctxsize); 951091d81d1SSam Leffler free(swd->sw_octx, M_CRYPTO_DATA); 952091d81d1SSam Leffler } 953091d81d1SSam Leffler break; 954091d81d1SSam Leffler 955091d81d1SSam Leffler case CRYPTO_MD5_KPDK: 956091d81d1SSam Leffler case CRYPTO_SHA1_KPDK: 957091d81d1SSam Leffler axf = swd->sw_axf; 958091d81d1SSam Leffler 959091d81d1SSam Leffler if (swd->sw_ictx) { 960091d81d1SSam Leffler bzero(swd->sw_ictx, axf->ctxsize); 961091d81d1SSam Leffler free(swd->sw_ictx, M_CRYPTO_DATA); 962091d81d1SSam Leffler } 963091d81d1SSam Leffler if (swd->sw_octx) { 964091d81d1SSam Leffler bzero(swd->sw_octx, swd->sw_klen); 965091d81d1SSam Leffler free(swd->sw_octx, M_CRYPTO_DATA); 966091d81d1SSam Leffler } 967091d81d1SSam Leffler break; 968091d81d1SSam Leffler 969091d81d1SSam Leffler case CRYPTO_MD5: 970091d81d1SSam Leffler case CRYPTO_SHA1: 971091d81d1SSam Leffler axf = swd->sw_axf; 972091d81d1SSam Leffler 973091d81d1SSam Leffler if (swd->sw_ictx) 974091d81d1SSam Leffler free(swd->sw_ictx, M_CRYPTO_DATA); 975091d81d1SSam Leffler break; 976091d81d1SSam Leffler 977091d81d1SSam Leffler case CRYPTO_DEFLATE_COMP: 978091d81d1SSam Leffler cxf = swd->sw_cxf; 979091d81d1SSam Leffler break; 980091d81d1SSam Leffler } 981091d81d1SSam Leffler 9821ede983cSDag-Erling Smørgrav free(swd, M_CRYPTO_DATA); 983091d81d1SSam Leffler } 984091d81d1SSam Leffler return 0; 985091d81d1SSam Leffler } 986091d81d1SSam Leffler 987091d81d1SSam Leffler /* 988091d81d1SSam Leffler * Process a software request. 989091d81d1SSam Leffler */ 990091d81d1SSam Leffler static int 9916810ad6fSSam Leffler swcr_process(device_t dev, struct cryptop *crp, int hint) 992091d81d1SSam Leffler { 993091d81d1SSam Leffler struct cryptodesc *crd; 994091d81d1SSam Leffler struct swcr_data *sw; 995091d81d1SSam Leffler u_int32_t lid; 996091d81d1SSam Leffler 997091d81d1SSam Leffler /* Sanity check */ 998091d81d1SSam Leffler if (crp == NULL) 999091d81d1SSam Leffler return EINVAL; 1000091d81d1SSam Leffler 1001091d81d1SSam Leffler if (crp->crp_desc == NULL || crp->crp_buf == NULL) { 1002091d81d1SSam Leffler crp->crp_etype = EINVAL; 1003091d81d1SSam Leffler goto done; 1004091d81d1SSam Leffler } 1005091d81d1SSam Leffler 1006091d81d1SSam Leffler lid = crp->crp_sid & 0xffffffff; 1007109919c6SBenno Rice rw_rlock(&swcr_sessions_lock); 1008109919c6SBenno Rice if (swcr_sessions == NULL || lid >= swcr_sesnum || lid == 0 || 1009109919c6SBenno Rice swcr_sessions[lid] == NULL) { 1010109919c6SBenno Rice rw_runlock(&swcr_sessions_lock); 1011091d81d1SSam Leffler crp->crp_etype = ENOENT; 1012091d81d1SSam Leffler goto done; 1013091d81d1SSam Leffler } 1014109919c6SBenno Rice rw_runlock(&swcr_sessions_lock); 1015091d81d1SSam Leffler 1016091d81d1SSam Leffler /* Go through crypto descriptors, processing as we go */ 1017091d81d1SSam Leffler for (crd = crp->crp_desc; crd; crd = crd->crd_next) { 1018091d81d1SSam Leffler /* 1019091d81d1SSam Leffler * Find the crypto context. 1020091d81d1SSam Leffler * 1021091d81d1SSam Leffler * XXX Note that the logic here prevents us from having 1022091d81d1SSam Leffler * XXX the same algorithm multiple times in a session 1023091d81d1SSam Leffler * XXX (or rather, we can but it won't give us the right 1024091d81d1SSam Leffler * XXX results). To do that, we'd need some way of differentiating 1025091d81d1SSam Leffler * XXX between the various instances of an algorithm (so we can 1026091d81d1SSam Leffler * XXX locate the correct crypto context). 1027091d81d1SSam Leffler */ 1028109919c6SBenno Rice rw_rlock(&swcr_sessions_lock); 1029109919c6SBenno Rice if (swcr_sessions == NULL) { 1030109919c6SBenno Rice rw_runlock(&swcr_sessions_lock); 1031109919c6SBenno Rice crp->crp_etype = ENOENT; 1032109919c6SBenno Rice goto done; 1033109919c6SBenno Rice } 1034091d81d1SSam Leffler for (sw = swcr_sessions[lid]; 1035091d81d1SSam Leffler sw && sw->sw_alg != crd->crd_alg; 1036091d81d1SSam Leffler sw = sw->sw_next) 1037091d81d1SSam Leffler ; 1038109919c6SBenno Rice rw_runlock(&swcr_sessions_lock); 1039091d81d1SSam Leffler 1040091d81d1SSam Leffler /* No such context ? */ 1041091d81d1SSam Leffler if (sw == NULL) { 1042091d81d1SSam Leffler crp->crp_etype = EINVAL; 1043091d81d1SSam Leffler goto done; 1044091d81d1SSam Leffler } 1045091d81d1SSam Leffler switch (sw->sw_alg) { 1046091d81d1SSam Leffler case CRYPTO_DES_CBC: 1047091d81d1SSam Leffler case CRYPTO_3DES_CBC: 1048091d81d1SSam Leffler case CRYPTO_BLF_CBC: 1049091d81d1SSam Leffler case CRYPTO_CAST_CBC: 1050091d81d1SSam Leffler case CRYPTO_SKIPJACK_CBC: 1051091d81d1SSam Leffler case CRYPTO_RIJNDAEL128_CBC: 1052d295bdeeSPawel Jakub Dawidek case CRYPTO_AES_XTS: 1053559d3390SGeorge V. Neville-Neil case CRYPTO_CAMELLIA_CBC: 1054091d81d1SSam Leffler if ((crp->crp_etype = swcr_encdec(crd, sw, 1055f34a967bSPawel Jakub Dawidek crp->crp_buf, crp->crp_flags)) != 0) 1056091d81d1SSam Leffler goto done; 1057091d81d1SSam Leffler break; 1058091d81d1SSam Leffler case CRYPTO_NULL_CBC: 1059091d81d1SSam Leffler crp->crp_etype = 0; 1060091d81d1SSam Leffler break; 1061091d81d1SSam Leffler case CRYPTO_MD5_HMAC: 1062091d81d1SSam Leffler case CRYPTO_SHA1_HMAC: 1063f6c4bc3bSPawel Jakub Dawidek case CRYPTO_SHA2_256_HMAC: 1064f6c4bc3bSPawel Jakub Dawidek case CRYPTO_SHA2_384_HMAC: 1065f6c4bc3bSPawel Jakub Dawidek case CRYPTO_SHA2_512_HMAC: 1066091d81d1SSam Leffler case CRYPTO_RIPEMD160_HMAC: 1067091d81d1SSam Leffler case CRYPTO_NULL_HMAC: 1068091d81d1SSam Leffler case CRYPTO_MD5_KPDK: 1069091d81d1SSam Leffler case CRYPTO_SHA1_KPDK: 1070091d81d1SSam Leffler case CRYPTO_MD5: 1071091d81d1SSam Leffler case CRYPTO_SHA1: 107238d2f8d6SPawel Jakub Dawidek if ((crp->crp_etype = swcr_authcompute(crd, sw, 1073f34a967bSPawel Jakub Dawidek crp->crp_buf, crp->crp_flags)) != 0) 1074091d81d1SSam Leffler goto done; 1075091d81d1SSam Leffler break; 1076091d81d1SSam Leffler 1077091d81d1SSam Leffler case CRYPTO_DEFLATE_COMP: 1078091d81d1SSam Leffler if ((crp->crp_etype = swcr_compdec(crd, sw, 1079f34a967bSPawel Jakub Dawidek crp->crp_buf, crp->crp_flags)) != 0) 1080091d81d1SSam Leffler goto done; 1081091d81d1SSam Leffler else 1082091d81d1SSam Leffler crp->crp_olen = (int)sw->sw_size; 1083091d81d1SSam Leffler break; 1084091d81d1SSam Leffler 1085091d81d1SSam Leffler default: 1086091d81d1SSam Leffler /* Unknown/unsupported algorithm */ 1087091d81d1SSam Leffler crp->crp_etype = EINVAL; 1088091d81d1SSam Leffler goto done; 1089091d81d1SSam Leffler } 1090091d81d1SSam Leffler } 1091091d81d1SSam Leffler 1092091d81d1SSam Leffler done: 1093091d81d1SSam Leffler crypto_done(crp); 1094091d81d1SSam Leffler return 0; 1095091d81d1SSam Leffler } 1096091d81d1SSam Leffler 1097091d81d1SSam Leffler static void 10983f147ab2SWarner Losh swcr_identify(driver_t *drv, device_t parent) 1099091d81d1SSam Leffler { 11006810ad6fSSam Leffler /* NB: order 10 is so we get attached after h/w devices */ 11016810ad6fSSam Leffler if (device_find_child(parent, "cryptosoft", -1) == NULL && 110286c585d9SMarius Strobl BUS_ADD_CHILD(parent, 10, "cryptosoft", 0) == 0) 11036810ad6fSSam Leffler panic("cryptosoft: could not attach"); 11046810ad6fSSam Leffler } 1105f6c4bc3bSPawel Jakub Dawidek 11066810ad6fSSam Leffler static int 11076810ad6fSSam Leffler swcr_probe(device_t dev) 11086810ad6fSSam Leffler { 11096810ad6fSSam Leffler device_set_desc(dev, "software crypto"); 111086c585d9SMarius Strobl return (BUS_PROBE_NOWILDCARD); 11116810ad6fSSam Leffler } 1112f6c4bc3bSPawel Jakub Dawidek 11136810ad6fSSam Leffler static int 11146810ad6fSSam Leffler swcr_attach(device_t dev) 11156810ad6fSSam Leffler { 1116109919c6SBenno Rice rw_init(&swcr_sessions_lock, "swcr_sessions_lock"); 11176810ad6fSSam Leffler memset(hmac_ipad_buffer, HMAC_IPAD_VAL, HMAC_MAX_BLOCK_LEN); 11186810ad6fSSam Leffler memset(hmac_opad_buffer, HMAC_OPAD_VAL, HMAC_MAX_BLOCK_LEN); 11196810ad6fSSam Leffler 11206810ad6fSSam Leffler swcr_id = crypto_get_driverid(dev, 11216810ad6fSSam Leffler CRYPTOCAP_F_SOFTWARE | CRYPTOCAP_F_SYNC); 11226810ad6fSSam Leffler if (swcr_id < 0) { 11236810ad6fSSam Leffler device_printf(dev, "cannot initialize!"); 11246810ad6fSSam Leffler return ENOMEM; 11256810ad6fSSam Leffler } 1126091d81d1SSam Leffler #define REGISTER(alg) \ 11276810ad6fSSam Leffler crypto_register(swcr_id, alg, 0,0) 11286810ad6fSSam Leffler REGISTER(CRYPTO_DES_CBC); 1129091d81d1SSam Leffler REGISTER(CRYPTO_3DES_CBC); 1130091d81d1SSam Leffler REGISTER(CRYPTO_BLF_CBC); 1131091d81d1SSam Leffler REGISTER(CRYPTO_CAST_CBC); 1132091d81d1SSam Leffler REGISTER(CRYPTO_SKIPJACK_CBC); 1133091d81d1SSam Leffler REGISTER(CRYPTO_NULL_CBC); 1134091d81d1SSam Leffler REGISTER(CRYPTO_MD5_HMAC); 1135091d81d1SSam Leffler REGISTER(CRYPTO_SHA1_HMAC); 1136f6c4bc3bSPawel Jakub Dawidek REGISTER(CRYPTO_SHA2_256_HMAC); 1137f6c4bc3bSPawel Jakub Dawidek REGISTER(CRYPTO_SHA2_384_HMAC); 1138f6c4bc3bSPawel Jakub Dawidek REGISTER(CRYPTO_SHA2_512_HMAC); 1139091d81d1SSam Leffler REGISTER(CRYPTO_RIPEMD160_HMAC); 1140091d81d1SSam Leffler REGISTER(CRYPTO_NULL_HMAC); 1141091d81d1SSam Leffler REGISTER(CRYPTO_MD5_KPDK); 1142091d81d1SSam Leffler REGISTER(CRYPTO_SHA1_KPDK); 1143091d81d1SSam Leffler REGISTER(CRYPTO_MD5); 1144091d81d1SSam Leffler REGISTER(CRYPTO_SHA1); 1145091d81d1SSam Leffler REGISTER(CRYPTO_RIJNDAEL128_CBC); 1146d295bdeeSPawel Jakub Dawidek REGISTER(CRYPTO_AES_XTS); 1147559d3390SGeorge V. Neville-Neil REGISTER(CRYPTO_CAMELLIA_CBC); 1148091d81d1SSam Leffler REGISTER(CRYPTO_DEFLATE_COMP); 1149091d81d1SSam Leffler #undef REGISTER 11506810ad6fSSam Leffler 11516810ad6fSSam Leffler return 0; 1152091d81d1SSam Leffler } 11534b465da2SPawel Jakub Dawidek 11543f147ab2SWarner Losh static int 11556810ad6fSSam Leffler swcr_detach(device_t dev) 11564b465da2SPawel Jakub Dawidek { 11576810ad6fSSam Leffler crypto_unregister_all(swcr_id); 1158109919c6SBenno Rice rw_wlock(&swcr_sessions_lock); 11591ede983cSDag-Erling Smørgrav free(swcr_sessions, M_CRYPTO_DATA); 1160109919c6SBenno Rice swcr_sessions = NULL; 1161109919c6SBenno Rice rw_wunlock(&swcr_sessions_lock); 1162109919c6SBenno Rice rw_destroy(&swcr_sessions_lock); 11633f147ab2SWarner Losh return 0; 11644b465da2SPawel Jakub Dawidek } 11656810ad6fSSam Leffler 11666810ad6fSSam Leffler static device_method_t swcr_methods[] = { 11676810ad6fSSam Leffler DEVMETHOD(device_identify, swcr_identify), 11686810ad6fSSam Leffler DEVMETHOD(device_probe, swcr_probe), 11696810ad6fSSam Leffler DEVMETHOD(device_attach, swcr_attach), 11706810ad6fSSam Leffler DEVMETHOD(device_detach, swcr_detach), 11716810ad6fSSam Leffler 11726810ad6fSSam Leffler DEVMETHOD(cryptodev_newsession, swcr_newsession), 11736810ad6fSSam Leffler DEVMETHOD(cryptodev_freesession,swcr_freesession), 11746810ad6fSSam Leffler DEVMETHOD(cryptodev_process, swcr_process), 11756810ad6fSSam Leffler 11766810ad6fSSam Leffler {0, 0}, 11776810ad6fSSam Leffler }; 11786810ad6fSSam Leffler 11796810ad6fSSam Leffler static driver_t swcr_driver = { 11806810ad6fSSam Leffler "cryptosoft", 11816810ad6fSSam Leffler swcr_methods, 11826810ad6fSSam Leffler 0, /* NB: no softc */ 11836810ad6fSSam Leffler }; 11846810ad6fSSam Leffler static devclass_t swcr_devclass; 11856810ad6fSSam Leffler 11866810ad6fSSam Leffler /* 11876810ad6fSSam Leffler * NB: We explicitly reference the crypto module so we 11886810ad6fSSam Leffler * get the necessary ordering when built as a loadable 11896810ad6fSSam Leffler * module. This is required because we bundle the crypto 11906810ad6fSSam Leffler * module code together with the cryptosoft driver (otherwise 11916810ad6fSSam Leffler * normal module dependencies would handle things). 11926810ad6fSSam Leffler */ 11936810ad6fSSam Leffler extern int crypto_modevent(struct module *, int, void *); 11946810ad6fSSam Leffler /* XXX where to attach */ 11956810ad6fSSam Leffler DRIVER_MODULE(cryptosoft, nexus, swcr_driver, swcr_devclass, crypto_modevent,0); 11966810ad6fSSam Leffler MODULE_VERSION(cryptosoft, 1); 11976810ad6fSSam Leffler MODULE_DEPEND(cryptosoft, crypto, 1, 1, 1); 1198