version 1.19, 2003/08/28 18:13:33 |
version 1.20, 2003/11/16 00:22:09 |
|
|
/* $NetBSD$ */ |
/* $NetBSD$ */ |
/* $FreeBSD: hifn7751.c,v 1.5.2.6 2003/07/02 17:04:50 sam Exp $ */ |
/* $FreeBSD: hifn7751.c,v 1.5.2.7 2003/10/08 23:52:00 sam Exp $ */ |
/* $OpenBSD: hifn7751.c,v 1.140 2003/08/01 17:55:54 deraadt Exp $ */ |
/* $OpenBSD: hifn7751.c,v 1.140 2003/08/01 17:55:54 deraadt Exp $ */ |
|
|
/* |
/* |
|
|
* Copyright (c) 1999 Theo de Raadt |
* Copyright (c) 1999 Theo de Raadt |
* Copyright (c) 2000-2001 Network Security Technologies, Inc. |
* Copyright (c) 2000-2001 Network Security Technologies, Inc. |
* http://www.netsec.net |
* http://www.netsec.net |
|
* Copyright (c) 2003 Hifn Inc. |
* |
* |
* This driver is based on a previous driver by Invertex, for which they |
* This driver is based on a previous driver by Invertex, for which they |
* requested: Please send any comments, feedback, bug-fixes, or feature |
* requested: Please send any comments, feedback, bug-fixes, or feature |
|
|
*/ |
*/ |
|
|
/* |
/* |
* Driver for the Hifn 7751 encryption processor. |
* Driver for various Hifn pre-HIPP encryption processors. |
*/ |
*/ |
|
|
#include <sys/cdefs.h> |
#include <sys/cdefs.h> |
Line 204 static const struct hifn_product { |
|
Line 205 static const struct hifn_product { |
|
"Hifn 7951", |
"Hifn 7951", |
}, |
}, |
|
|
|
{ PCI_VENDOR_HIFN, PCI_PRODUCT_HIFN_7955, |
|
HIFN_HAS_RNG | HIFN_HAS_PUBLIC | HIFN_IS_7956 | HIFN_HAS_AES, |
|
"Hifn 7955", |
|
}, |
|
|
|
{ PCI_VENDOR_HIFN, PCI_PRODUCT_HIFN_7956, |
|
HIFN_HAS_RNG | HIFN_HAS_PUBLIC | HIFN_IS_7956 | HIFN_HAS_AES, |
|
"Hifn 7956", |
|
}, |
|
|
|
|
{ 0, 0, |
{ 0, 0, |
0, |
0, |
Line 341 hifn_attach(struct device *parent, struc |
|
Line 352 hifn_attach(struct device *parent, struc |
|
hifn_init_dma(sc); |
hifn_init_dma(sc); |
hifn_init_pci_registers(sc); |
hifn_init_pci_registers(sc); |
|
|
if (hifn_ramtype(sc)) |
/* XXX can't dynamically determine ram type for 795x; force dram */ |
|
if (sc->sc_flags & HIFN_IS_7956) |
|
sc->sc_drammodel = 1; |
|
else if (hifn_ramtype(sc)) |
goto fail_mem; |
goto fail_mem; |
|
|
if (sc->sc_drammodel == 0) |
if (sc->sc_drammodel == 0) |
Line 408 hifn_attach(struct device *parent, struc |
|
Line 422 hifn_attach(struct device *parent, struc |
|
hifn_newsession, hifn_freesession, hifn_process, sc); |
hifn_newsession, hifn_freesession, hifn_process, sc); |
crypto_register(sc->sc_cid, CRYPTO_ARC4, 0, 0, |
crypto_register(sc->sc_cid, CRYPTO_ARC4, 0, 0, |
hifn_newsession, hifn_freesession, hifn_process, sc); |
hifn_newsession, hifn_freesession, hifn_process, sc); |
|
if (sc->sc_flags & HIFN_HAS_AES) |
|
crypto_register(sc->sc_cid, CRYPTO_AES_CBC, 0, 0, |
|
hifn_newsession, hifn_freesession, |
|
hifn_process, sc); |
/*FALLTHROUGH*/ |
/*FALLTHROUGH*/ |
case HIFN_PUSTAT_ENA_1: |
case HIFN_PUSTAT_ENA_1: |
crypto_register(sc->sc_cid, CRYPTO_MD5, 0, 0, |
crypto_register(sc->sc_cid, CRYPTO_MD5, 0, 0, |
|
|
{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, |
{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, |
0x00, 0x00, 0x00, 0x00, 0x00 } |
0x00, 0x00, 0x00, 0x00, 0x00 } |
}, { |
}, { |
|
PCI_VENDOR_HIFN, |
|
PCI_PRODUCT_HIFN_7955, |
|
{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, |
|
0x00, 0x00, 0x00, 0x00, 0x00 } |
|
}, { |
|
PCI_VENDOR_HIFN, |
|
PCI_PRODUCT_HIFN_7956, |
|
{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, |
|
0x00, 0x00, 0x00, 0x00, 0x00 } |
|
}, { |
PCI_VENDOR_NETSEC, |
PCI_VENDOR_NETSEC, |
PCI_PRODUCT_NETSEC_7751, |
PCI_PRODUCT_NETSEC_7751, |
{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, |
{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, |
Line 880 hifn_init_pci_registers(struct hifn_soft |
|
Line 908 hifn_init_pci_registers(struct hifn_soft |
|
WRITE_REG_1(sc, HIFN_1_DMA_IER, sc->sc_dmaier); |
WRITE_REG_1(sc, HIFN_1_DMA_IER, sc->sc_dmaier); |
CLR_LED(sc, HIFN_MIPSRST_LED0 | HIFN_MIPSRST_LED1 | HIFN_MIPSRST_LED2); |
CLR_LED(sc, HIFN_MIPSRST_LED0 | HIFN_MIPSRST_LED1 | HIFN_MIPSRST_LED2); |
|
|
WRITE_REG_0(sc, HIFN_0_PUCNFG, HIFN_PUCNFG_COMPSING | |
if (sc->sc_flags & HIFN_IS_7956) { |
HIFN_PUCNFG_DRFR_128 | HIFN_PUCNFG_TCALLPHASES | |
WRITE_REG_0(sc, HIFN_0_PUCNFG, HIFN_PUCNFG_COMPSING | |
HIFN_PUCNFG_TCDRVTOTEM | HIFN_PUCNFG_BUS32 | |
HIFN_PUCNFG_TCALLPHASES | |
(sc->sc_drammodel ? HIFN_PUCNFG_DRAM : HIFN_PUCNFG_SRAM)); |
HIFN_PUCNFG_TCDRVTOTEM | HIFN_PUCNFG_BUS32); |
|
WRITE_REG_1(sc, HIFN_1_PLL, HIFN_PLL_7956); |
|
} else { |
|
WRITE_REG_0(sc, HIFN_0_PUCNFG, HIFN_PUCNFG_COMPSING | |
|
HIFN_PUCNFG_DRFR_128 | HIFN_PUCNFG_TCALLPHASES | |
|
HIFN_PUCNFG_TCDRVTOTEM | HIFN_PUCNFG_BUS32 | |
|
(sc->sc_drammodel ? HIFN_PUCNFG_DRAM : HIFN_PUCNFG_SRAM)); |
|
} |
|
|
WRITE_REG_0(sc, HIFN_0_PUISR, HIFN_PUISR_DSTOVER); |
WRITE_REG_0(sc, HIFN_0_PUISR, HIFN_PUISR_DSTOVER); |
WRITE_REG_1(sc, HIFN_1_DMA_CNFG, HIFN_DMACNFG_MSTRESET | |
WRITE_REG_1(sc, HIFN_1_DMA_CNFG, HIFN_DMACNFG_MSTRESET | |
Line 912 hifn_sessions(struct hifn_softc *sc) |
|
Line 947 hifn_sessions(struct hifn_softc *sc) |
|
ctxsize = 128; |
ctxsize = 128; |
else |
else |
ctxsize = 512; |
ctxsize = 512; |
sc->sc_maxses = 1 + |
/* |
((sc->sc_ramsize - 32768) / ctxsize); |
* 7955/7956 has internal context memory of 32K |
|
*/ |
|
if (sc->sc_flags & HIFN_IS_7956) |
|
sc->sc_maxses = 32768 / ctxsize; |
|
else |
|
sc->sc_maxses = 1 + |
|
((sc->sc_ramsize - 32768) / ctxsize); |
} |
} |
else |
else |
sc->sc_maxses = sc->sc_ramsize / 16384; |
sc->sc_maxses = sc->sc_ramsize / 16384; |
Line 1001 hifn_dramsize(struct hifn_softc *sc) |
|
Line 1042 hifn_dramsize(struct hifn_softc *sc) |
|
{ |
{ |
u_int32_t cnfg; |
u_int32_t cnfg; |
|
|
cnfg = READ_REG_0(sc, HIFN_0_PUCNFG) & |
if (sc->sc_flags & HIFN_IS_7956) { |
HIFN_PUCNFG_DRAMMASK; |
/* |
sc->sc_ramsize = 1 << ((cnfg >> 13) + 18); |
* 7955/7956 have a fixed internal ram of only 32K. |
|
*/ |
|
sc->sc_ramsize = 32768; |
|
} else { |
|
cnfg = READ_REG_0(sc, HIFN_0_PUCNFG) & |
|
HIFN_PUCNFG_DRAMMASK; |
|
sc->sc_ramsize = 1 << ((cnfg >> 13) + 18); |
|
} |
return (0); |
return (0); |
} |
} |
|
|
Line 1233 hifn_write_command(struct hifn_command * |
|
Line 1281 hifn_write_command(struct hifn_command * |
|
struct hifn_mac_command *mac_cmd; |
struct hifn_mac_command *mac_cmd; |
struct hifn_crypt_command *cry_cmd; |
struct hifn_crypt_command *cry_cmd; |
struct hifn_comp_command *comp_cmd; |
struct hifn_comp_command *comp_cmd; |
int using_mac, using_crypt, using_comp, len; |
int using_mac, using_crypt, using_comp, len, ivlen; |
u_int32_t dlen, slen; |
u_int32_t dlen, slen; |
|
|
buf_pos = buf; |
buf_pos = buf; |
Line 1307 hifn_write_command(struct hifn_command * |
|
Line 1355 hifn_write_command(struct hifn_command * |
|
break; |
break; |
case HIFN_CRYPT_CMD_ALG_DES: |
case HIFN_CRYPT_CMD_ALG_DES: |
bcopy(cmd->ck, buf_pos, HIFN_DES_KEY_LENGTH); |
bcopy(cmd->ck, buf_pos, HIFN_DES_KEY_LENGTH); |
buf_pos += cmd->cklen; |
buf_pos += HIFN_DES_KEY_LENGTH; |
break; |
break; |
case HIFN_CRYPT_CMD_ALG_RC4: |
case HIFN_CRYPT_CMD_ALG_RC4: |
len = 256; |
len = 256; |
Line 1322 hifn_write_command(struct hifn_command * |
|
Line 1370 hifn_write_command(struct hifn_command * |
|
bzero(buf_pos, 4); |
bzero(buf_pos, 4); |
buf_pos += 4; |
buf_pos += 4; |
break; |
break; |
|
case HIFN_CRYPT_CMD_ALG_AES: |
|
/* |
|
* AES keys are variable 128, 192 and |
|
* 256 bits (16, 24 and 32 bytes). |
|
*/ |
|
bcopy(cmd->ck, buf_pos, cmd->cklen); |
|
buf_pos += cmd->cklen; |
|
break; |
} |
} |
} |
} |
|
|
if (using_crypt && cmd->cry_masks & HIFN_CRYPT_CMD_NEW_IV) { |
if (using_crypt && cmd->cry_masks & HIFN_CRYPT_CMD_NEW_IV) { |
bcopy(cmd->iv, buf_pos, HIFN_IV_LENGTH); |
switch (cmd->cry_masks & HIFN_CRYPT_CMD_ALG_MASK) { |
buf_pos += HIFN_IV_LENGTH; |
case HIFN_CRYPT_CMD_ALG_AES: |
|
ivlen = HIFN_AES_IV_LENGTH; |
|
break; |
|
default: |
|
ivlen = HIFN_IV_LENGTH; |
|
break; |
|
} |
|
bcopy(cmd->iv, buf_pos, ivlen); |
|
buf_pos += ivlen; |
} |
} |
|
|
if ((cmd->base_masks & (HIFN_BASE_CMD_MAC | HIFN_BASE_CMD_CRYPT | |
if ((cmd->base_masks & (HIFN_BASE_CMD_MAC | HIFN_BASE_CMD_CRYPT | |
Line 1935 hifn_newsession(void *arg, u_int32_t *si |
|
Line 1999 hifn_newsession(void *arg, u_int32_t *si |
|
break; |
break; |
case CRYPTO_DES_CBC: |
case CRYPTO_DES_CBC: |
case CRYPTO_3DES_CBC: |
case CRYPTO_3DES_CBC: |
|
case CRYPTO_AES_CBC: |
#ifdef __NetBSD__ |
#ifdef __NetBSD__ |
rnd_extract_data(sc->sc_sessions[i].hs_iv, |
rnd_extract_data(sc->sc_sessions[i].hs_iv, |
HIFN_IV_LENGTH, RND_EXTRACT_ANY); |
c->cri_alg == CRYPTO_AES_CBC ? |
|
HIFN_AES_IV_LENGTH : HIFN_IV_LENGTH, |
|
RND_EXTRACT_ANY); |
#else /* FreeBSD and OpenBSD have get_random_bytes */ |
#else /* FreeBSD and OpenBSD have get_random_bytes */ |
/* XXX this may read fewer, does it matter? */ |
/* XXX this may read fewer, does it matter? */ |
get_random_bytes(sc->sc_sessions[i].hs_iv, |
get_random_bytes(sc->sc_sessions[i].hs_iv, |
HIFN_IV_LENGTH); |
c->cri_alg == CRYPTO_AES_CBC ? |
|
HIFN_AES_IV_LENGTH : HIFN_IV_LENGTH); |
#endif |
#endif |
/*FALLTHROUGH*/ |
/*FALLTHROUGH*/ |
case CRYPTO_ARC4: |
case CRYPTO_ARC4: |
Line 2005 hifn_process(void *arg, struct cryptop * |
|
Line 2073 hifn_process(void *arg, struct cryptop * |
|
{ |
{ |
struct hifn_softc *sc = arg; |
struct hifn_softc *sc = arg; |
struct hifn_command *cmd = NULL; |
struct hifn_command *cmd = NULL; |
int session, err; |
int session, err, ivlen; |
struct cryptodesc *crd1, *crd2, *maccrd, *enccrd; |
struct cryptodesc *crd1, *crd2, *maccrd, *enccrd; |
|
|
if (crp == NULL || crp->crp_callback == NULL) { |
if (crp == NULL || crp->crp_callback == NULL) { |
Line 2054 hifn_process(void *arg, struct cryptop * |
|
Line 2122 hifn_process(void *arg, struct cryptop * |
|
enccrd = NULL; |
enccrd = NULL; |
} else if (crd1->crd_alg == CRYPTO_DES_CBC || |
} else if (crd1->crd_alg == CRYPTO_DES_CBC || |
crd1->crd_alg == CRYPTO_3DES_CBC || |
crd1->crd_alg == CRYPTO_3DES_CBC || |
|
crd1->crd_alg == CRYPTO_AES_CBC || |
crd1->crd_alg == CRYPTO_ARC4) { |
crd1->crd_alg == CRYPTO_ARC4) { |
if ((crd1->crd_flags & CRD_F_ENCRYPT) == 0) |
if ((crd1->crd_flags & CRD_F_ENCRYPT) == 0) |
cmd->base_masks |= HIFN_BASE_CMD_DECODE; |
cmd->base_masks |= HIFN_BASE_CMD_DECODE; |
Line 2074 hifn_process(void *arg, struct cryptop * |
|
Line 2143 hifn_process(void *arg, struct cryptop * |
|
crd1->crd_alg == CRYPTO_SHA1) && |
crd1->crd_alg == CRYPTO_SHA1) && |
(crd2->crd_alg == CRYPTO_DES_CBC || |
(crd2->crd_alg == CRYPTO_DES_CBC || |
crd2->crd_alg == CRYPTO_3DES_CBC || |
crd2->crd_alg == CRYPTO_3DES_CBC || |
|
crd2->crd_alg == CRYPTO_AES_CBC || |
crd2->crd_alg == CRYPTO_ARC4) && |
crd2->crd_alg == CRYPTO_ARC4) && |
((crd2->crd_flags & CRD_F_ENCRYPT) == 0)) { |
((crd2->crd_flags & CRD_F_ENCRYPT) == 0)) { |
cmd->base_masks = HIFN_BASE_CMD_DECODE; |
cmd->base_masks = HIFN_BASE_CMD_DECODE; |
Line 2081 hifn_process(void *arg, struct cryptop * |
|
Line 2151 hifn_process(void *arg, struct cryptop * |
|
enccrd = crd2; |
enccrd = crd2; |
} else if ((crd1->crd_alg == CRYPTO_DES_CBC || |
} else if ((crd1->crd_alg == CRYPTO_DES_CBC || |
crd1->crd_alg == CRYPTO_ARC4 || |
crd1->crd_alg == CRYPTO_ARC4 || |
crd1->crd_alg == CRYPTO_3DES_CBC) && |
crd1->crd_alg == CRYPTO_3DES_CBC || |
|
crd1->crd_alg == CRYPTO_AES_CBC) && |
(crd2->crd_alg == CRYPTO_MD5_HMAC || |
(crd2->crd_alg == CRYPTO_MD5_HMAC || |
crd2->crd_alg == CRYPTO_SHA1_HMAC || |
crd2->crd_alg == CRYPTO_SHA1_HMAC || |
crd2->crd_alg == CRYPTO_MD5 || |
crd2->crd_alg == CRYPTO_MD5 || |
Line 2119 hifn_process(void *arg, struct cryptop * |
|
Line 2190 hifn_process(void *arg, struct cryptop * |
|
HIFN_CRYPT_CMD_MODE_CBC | |
HIFN_CRYPT_CMD_MODE_CBC | |
HIFN_CRYPT_CMD_NEW_IV; |
HIFN_CRYPT_CMD_NEW_IV; |
break; |
break; |
|
case CRYPTO_AES_CBC: |
|
cmd->cry_masks |= HIFN_CRYPT_CMD_ALG_AES | |
|
HIFN_CRYPT_CMD_MODE_CBC | |
|
HIFN_CRYPT_CMD_NEW_IV; |
|
break; |
default: |
default: |
err = EINVAL; |
err = EINVAL; |
goto errout; |
goto errout; |
} |
} |
if (enccrd->crd_alg != CRYPTO_ARC4) { |
if (enccrd->crd_alg != CRYPTO_ARC4) { |
|
ivlen = ((enccrd->crd_alg == CRYPTO_AES_CBC) ? |
|
HIFN_AES_IV_LENGTH : HIFN_IV_LENGTH); |
if (enccrd->crd_flags & CRD_F_ENCRYPT) { |
if (enccrd->crd_flags & CRD_F_ENCRYPT) { |
if (enccrd->crd_flags & CRD_F_IV_EXPLICIT) |
if (enccrd->crd_flags & CRD_F_IV_EXPLICIT) |
bcopy(enccrd->crd_iv, cmd->iv, |
bcopy(enccrd->crd_iv, cmd->iv, ivlen); |
HIFN_IV_LENGTH); |
|
else |
else |
bcopy(sc->sc_sessions[session].hs_iv, |
bcopy(sc->sc_sessions[session].hs_iv, |
cmd->iv, HIFN_IV_LENGTH); |
cmd->iv, ivlen); |
|
|
if ((enccrd->crd_flags & CRD_F_IV_PRESENT) |
if ((enccrd->crd_flags & CRD_F_IV_PRESENT) |
== 0) { |
== 0) { |
if (crp->crp_flags & CRYPTO_F_IMBUF) |
if (crp->crp_flags & CRYPTO_F_IMBUF) |
m_copyback(cmd->srcu.src_m, |
m_copyback(cmd->srcu.src_m, |
enccrd->crd_inject, |
enccrd->crd_inject, |
HIFN_IV_LENGTH, cmd->iv); |
ivlen, cmd->iv); |
else if (crp->crp_flags & CRYPTO_F_IOV) |
else if (crp->crp_flags & CRYPTO_F_IOV) |
cuio_copyback(cmd->srcu.src_io, |
cuio_copyback(cmd->srcu.src_io, |
enccrd->crd_inject, |
enccrd->crd_inject, |
HIFN_IV_LENGTH, cmd->iv); |
ivlen, cmd->iv); |
} |
} |
} else { |
} else { |
if (enccrd->crd_flags & CRD_F_IV_EXPLICIT) |
if (enccrd->crd_flags & CRD_F_IV_EXPLICIT) |
bcopy(enccrd->crd_iv, cmd->iv, |
bcopy(enccrd->crd_iv, cmd->iv, ivlen); |
HIFN_IV_LENGTH); |
|
else if (crp->crp_flags & CRYPTO_F_IMBUF) |
else if (crp->crp_flags & CRYPTO_F_IMBUF) |
m_copydata(cmd->srcu.src_m, |
m_copydata(cmd->srcu.src_m, |
enccrd->crd_inject, |
enccrd->crd_inject, ivlen, cmd->iv); |
HIFN_IV_LENGTH, cmd->iv); |
|
else if (crp->crp_flags & CRYPTO_F_IOV) |
else if (crp->crp_flags & CRYPTO_F_IOV) |
cuio_copydata(cmd->srcu.src_io, |
cuio_copydata(cmd->srcu.src_io, |
enccrd->crd_inject, |
enccrd->crd_inject, ivlen, cmd->iv); |
HIFN_IV_LENGTH, cmd->iv); |
|
} |
} |
} |
} |
|
|
cmd->ck = enccrd->crd_key; |
cmd->ck = enccrd->crd_key; |
cmd->cklen = enccrd->crd_klen >> 3; |
cmd->cklen = enccrd->crd_klen >> 3; |
|
|
|
/* |
|
* Need to specify the size for the AES key in the masks. |
|
*/ |
|
if ((cmd->cry_masks & HIFN_CRYPT_CMD_ALG_MASK) == |
|
HIFN_CRYPT_CMD_ALG_AES) { |
|
switch (cmd->cklen) { |
|
case 16: |
|
cmd->cry_masks |= HIFN_CRYPT_CMD_KSZ_128; |
|
break; |
|
case 24: |
|
cmd->cry_masks |= HIFN_CRYPT_CMD_KSZ_192; |
|
break; |
|
case 32: |
|
cmd->cry_masks |= HIFN_CRYPT_CMD_KSZ_256; |
|
break; |
|
default: |
|
err = EINVAL; |
|
goto errout; |
|
} |
|
} |
|
|
if (sc->sc_sessions[session].hs_state == HS_STATE_USED) |
if (sc->sc_sessions[session].hs_state == HS_STATE_USED) |
cmd->cry_masks |= HIFN_CRYPT_CMD_NEW_KEY; |
cmd->cry_masks |= HIFN_CRYPT_CMD_NEW_KEY; |
} |
} |
Line 2329 hifn_callback(struct hifn_softc *sc, str |
|
Line 2424 hifn_callback(struct hifn_softc *sc, str |
|
struct cryptop *crp = cmd->crp; |
struct cryptop *crp = cmd->crp; |
struct cryptodesc *crd; |
struct cryptodesc *crd; |
struct mbuf *m; |
struct mbuf *m; |
int totlen, i, u; |
int totlen, i, u, ivlen; |
|
|
if (cmd->src_map == cmd->dst_map) |
if (cmd->src_map == cmd->dst_map) |
bus_dmamap_sync(sc->sc_dmat, cmd->src_map, |
bus_dmamap_sync(sc->sc_dmat, cmd->src_map, |
Line 2395 hifn_callback(struct hifn_softc *sc, str |
|
Line 2490 hifn_callback(struct hifn_softc *sc, str |
|
HIFN_BASE_CMD_CRYPT) { |
HIFN_BASE_CMD_CRYPT) { |
for (crd = crp->crp_desc; crd; crd = crd->crd_next) { |
for (crd = crp->crp_desc; crd; crd = crd->crd_next) { |
if (crd->crd_alg != CRYPTO_DES_CBC && |
if (crd->crd_alg != CRYPTO_DES_CBC && |
crd->crd_alg != CRYPTO_3DES_CBC) |
crd->crd_alg != CRYPTO_3DES_CBC && |
|
crd->crd_alg != CRYPTO_AES_CBC) |
continue; |
continue; |
|
ivlen = ((crd->crd_alg == CRYPTO_AES_CBC) ? |
|
HIFN_AES_IV_LENGTH : HIFN_IV_LENGTH); |
if (crp->crp_flags & CRYPTO_F_IMBUF) |
if (crp->crp_flags & CRYPTO_F_IMBUF) |
m_copydata((struct mbuf *)crp->crp_buf, |
m_copydata((struct mbuf *)crp->crp_buf, |
crd->crd_skip + crd->crd_len - HIFN_IV_LENGTH, |
crd->crd_skip + crd->crd_len - ivlen, |
HIFN_IV_LENGTH, |
ivlen, |
cmd->softc->sc_sessions[cmd->session_num].hs_iv); |
cmd->softc->sc_sessions[cmd->session_num].hs_iv); |
else if (crp->crp_flags & CRYPTO_F_IOV) { |
else if (crp->crp_flags & CRYPTO_F_IOV) { |
cuio_copydata((struct uio *)crp->crp_buf, |
cuio_copydata((struct uio *)crp->crp_buf, |
crd->crd_skip + crd->crd_len - HIFN_IV_LENGTH, |
crd->crd_skip + crd->crd_len - ivlen, |
HIFN_IV_LENGTH, |
ivlen, |
cmd->softc->sc_sessions[cmd->session_num].hs_iv); |
cmd->softc->sc_sessions[cmd->session_num].hs_iv); |
} |
} |
/* XXX We do not handle contig data */ |
/* XXX We do not handle contig data */ |