19d3b47b92
Mainly focus on files that use BSD 2-Clause license, however the tool I was using misidentified many licenses so this was mostly a manual - error prone - task. The Software Package Data Exchange (SPDX) group provides a specification to make it easier for automated tools to detect and summarize well known opensource licenses. We are gradually adopting the specification, noting that the tags are considered only advisory and do not, in any way, superceed or replace the license texts.
608 lines
19 KiB
C
608 lines
19 KiB
C
/*-
|
|
* SPDX-License-Identifier: BSD-2-Clause-FreeBSD
|
|
*
|
|
* Copyright (c) 2003-2012 Broadcom Corporation
|
|
* All Rights Reserved
|
|
*
|
|
* Redistribution and use in source and binary forms, with or without
|
|
* modification, are permitted provided that the following conditions
|
|
* are met:
|
|
*
|
|
* 1. Redistributions of source code must retain the above copyright
|
|
* notice, this list of conditions and the following disclaimer.
|
|
* 2. Redistributions in binary form must reproduce the above copyright
|
|
* notice, this list of conditions and the following disclaimer in
|
|
* the documentation and/or other materials provided with the
|
|
* distribution.
|
|
*
|
|
* THIS SOFTWARE IS PROVIDED BY BROADCOM ``AS IS'' AND ANY EXPRESS OR
|
|
* IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
|
|
* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
|
|
* ARE DISCLAIMED. IN NO EVENT SHALL BROADCOM OR CONTRIBUTORS BE LIABLE
|
|
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
|
|
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
|
|
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
|
|
* BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
|
|
* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
|
|
* OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
|
|
* IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|
*
|
|
* $FreeBSD$
|
|
*/
|
|
|
|
#ifndef _NLM_HAL_CRYPTO_H_
|
|
#define _NLM_HAL_CRYPTO_H_
|
|
|
|
#define SAE_CFG_REG 0x00
|
|
#define SAE_ENG_SEL_0 0x01
|
|
#define SAE_ENG_SEL_1 0x02
|
|
#define SAE_ENG_SEL_2 0x03
|
|
#define SAE_ENG_SEL_3 0x04
|
|
#define SAE_ENG_SEL_4 0x05
|
|
#define SAE_ENG_SEL_5 0x06
|
|
#define SAE_ENG_SEL_6 0x07
|
|
#define SAE_ENG_SEL_7 0x08
|
|
|
|
#define RSA_CFG_REG 0x00
|
|
#define RSA_ENG_SEL_0 0x01
|
|
#define RSA_ENG_SEL_1 0x02
|
|
#define RSA_ENG_SEL_2 0x03
|
|
|
|
#define nlm_read_sec_reg(b, r) nlm_read_reg(b, r)
|
|
#define nlm_write_sec_reg(b, r, v) nlm_write_reg(b, r, v)
|
|
#define nlm_get_sec_pcibase(node) nlm_pcicfg_base(XLP_IO_SEC_OFFSET(node))
|
|
#define nlm_get_sec_regbase(node) \
|
|
(nlm_get_sec_pcibase(node) + XLP_IO_PCI_HDRSZ)
|
|
|
|
#define nlm_read_rsa_reg(b, r) nlm_read_reg(b, r)
|
|
#define nlm_write_rsa_reg(b, r, v) nlm_write_reg(b, r, v)
|
|
#define nlm_get_rsa_pcibase(node) nlm_pcicfg_base(XLP_IO_RSA_OFFSET(node))
|
|
#define nlm_get_rsa_regbase(node) \
|
|
(nlm_get_rsa_pcibase(node) + XLP_IO_PCI_HDRSZ)
|
|
|
|
#define nlm_pcibase_sec(node) nlm_pcicfg_base(XLP_IO_SEC_OFFSET(node))
|
|
#define nlm_qidstart_sec(node) nlm_qidstart_kseg(nlm_pcibase_sec(node))
|
|
#define nlm_qnum_sec(node) nlm_qnum_kseg(nlm_pcibase_sec(node))
|
|
|
|
/*
|
|
* Since buffer allocation for crypto at kernel is done as malloc, each
|
|
* segment size is given as page size which is 4K by default
|
|
*/
|
|
#define NLM_CRYPTO_MAX_SEG_LEN PAGE_SIZE
|
|
|
|
#define MAX_KEY_LEN_IN_DW 20
|
|
|
|
#define left_shift64(x, bitshift, numofbits) \
|
|
((uint64_t)(x) << (bitshift))
|
|
|
|
#define left_shift64_mask(x, bitshift, numofbits) \
|
|
(((uint64_t)(x) & ((1ULL << (numofbits)) - 1)) << (bitshift))
|
|
|
|
/**
|
|
* @brief cipher algorithms
|
|
* @ingroup crypto
|
|
*/
|
|
enum nlm_cipher_algo {
|
|
NLM_CIPHER_BYPASS = 0,
|
|
NLM_CIPHER_DES = 1,
|
|
NLM_CIPHER_3DES = 2,
|
|
NLM_CIPHER_AES128 = 3,
|
|
NLM_CIPHER_AES192 = 4,
|
|
NLM_CIPHER_AES256 = 5,
|
|
NLM_CIPHER_ARC4 = 6,
|
|
NLM_CIPHER_KASUMI_F8 = 7,
|
|
NLM_CIPHER_SNOW3G_F8 = 8,
|
|
NLM_CIPHER_CAMELLIA128 = 9,
|
|
NLM_CIPHER_CAMELLIA192 = 0xA,
|
|
NLM_CIPHER_CAMELLIA256 = 0xB,
|
|
NLM_CIPHER_MAX = 0xC,
|
|
};
|
|
|
|
/**
|
|
* @brief cipher modes
|
|
* @ingroup crypto
|
|
*/
|
|
enum nlm_cipher_mode {
|
|
NLM_CIPHER_MODE_ECB = 0,
|
|
NLM_CIPHER_MODE_CBC = 1,
|
|
NLM_CIPHER_MODE_CFB = 2,
|
|
NLM_CIPHER_MODE_OFB = 3,
|
|
NLM_CIPHER_MODE_CTR = 4,
|
|
NLM_CIPHER_MODE_AES_F8 = 5,
|
|
NLM_CIPHER_MODE_GCM = 6,
|
|
NLM_CIPHER_MODE_CCM = 7,
|
|
NLM_CIPHER_MODE_UNDEFINED1 = 8,
|
|
NLM_CIPHER_MODE_UNDEFINED2 = 9,
|
|
NLM_CIPHER_MODE_LRW = 0xA,
|
|
NLM_CIPHER_MODE_XTS = 0xB,
|
|
NLM_CIPHER_MODE_MAX = 0xC,
|
|
};
|
|
|
|
/**
|
|
* @brief hash algorithms
|
|
* @ingroup crypto
|
|
*/
|
|
enum nlm_hash_algo {
|
|
NLM_HASH_BYPASS = 0,
|
|
NLM_HASH_MD5 = 1,
|
|
NLM_HASH_SHA = 2,
|
|
NLM_HASH_UNDEFINED = 3,
|
|
NLM_HASH_AES128 = 4,
|
|
NLM_HASH_AES192 = 5,
|
|
NLM_HASH_AES256 = 6,
|
|
NLM_HASH_KASUMI_F9 = 7,
|
|
NLM_HASH_SNOW3G_F9 = 8,
|
|
NLM_HASH_CAMELLIA128 = 9,
|
|
NLM_HASH_CAMELLIA192 = 0xA,
|
|
NLM_HASH_CAMELLIA256 = 0xB,
|
|
NLM_HASH_GHASH = 0xC,
|
|
NLM_HASH_MAX = 0xD
|
|
};
|
|
|
|
/**
|
|
* @brief hash modes
|
|
* @ingroup crypto
|
|
*/
|
|
enum nlm_hash_mode {
|
|
NLM_HASH_MODE_SHA1 = 0, /* Only SHA */
|
|
NLM_HASH_MODE_SHA224 = 1, /* Only SHA */
|
|
NLM_HASH_MODE_SHA256 = 2, /* Only SHA */
|
|
NLM_HASH_MODE_SHA384 = 3, /* Only SHA */
|
|
NLM_HASH_MODE_SHA512 = 4, /* Only SHA */
|
|
NLM_HASH_MODE_CMAC = 5, /* AES and Camellia */
|
|
NLM_HASH_MODE_XCBC = 6, /* AES and Camellia */
|
|
NLM_HASH_MODE_CBC_MAC = 7, /* AES and Camellia */
|
|
NLM_HASH_MODE_CCM = 8, /* AES */
|
|
NLM_HASH_MODE_GCM = 9, /* AES */
|
|
NLM_HASH_MODE_MAX = 0xA,
|
|
};
|
|
|
|
/**
|
|
* @brief crypto control descriptor, should be cache aligned
|
|
* @ingroup crypto
|
|
*/
|
|
struct nlm_crypto_pkt_ctrl {
|
|
uint64_t desc0;
|
|
/* combination of cipher and hash keys */
|
|
uint64_t key[MAX_KEY_LEN_IN_DW];
|
|
uint32_t cipherkeylen;
|
|
uint32_t hashkeylen;
|
|
uint32_t taglen;
|
|
};
|
|
|
|
/**
|
|
* @brief crypto packet descriptor, should be cache aligned
|
|
* @ingroup crypto
|
|
*/
|
|
struct nlm_crypto_pkt_param {
|
|
uint64_t desc0;
|
|
uint64_t desc1;
|
|
uint64_t desc2;
|
|
uint64_t desc3;
|
|
uint64_t segment[1][2];
|
|
};
|
|
|
|
static __inline__ uint64_t
|
|
nlm_crypto_form_rsa_ecc_fmn_entry0(unsigned int l3alloc, unsigned int type,
|
|
unsigned int func, uint64_t srcaddr)
|
|
{
|
|
return (left_shift64(l3alloc, 61, 1) |
|
|
left_shift64(type, 46, 7) |
|
|
left_shift64(func, 40, 6) |
|
|
left_shift64(srcaddr, 0, 40));
|
|
}
|
|
|
|
static __inline__ uint64_t
|
|
nlm_crypto_form_rsa_ecc_fmn_entry1(unsigned int dstclobber,
|
|
unsigned int l3alloc, unsigned int fbvc, uint64_t dstaddr)
|
|
{
|
|
return (left_shift64(dstclobber, 62, 1) |
|
|
left_shift64(l3alloc, 61, 1) |
|
|
left_shift64(fbvc, 40, 12) |
|
|
left_shift64(dstaddr, 0, 40));
|
|
}
|
|
|
|
/**
|
|
* @brief Generate cypto control descriptor
|
|
* @ingroup crypto
|
|
* hmac : 1 for hash with hmac
|
|
* hashalg, see hash_alg enums
|
|
* hashmode, see hash_mode enums
|
|
* cipherhalg, see cipher_alg enums
|
|
* ciphermode, see cipher_mode enums
|
|
* arc4_cipherkeylen : length of arc4 cipher key, 0 is interpreted as 32
|
|
* arc4_keyinit :
|
|
* cfbmask : cipher text for feedback,
|
|
* 0(1 bit), 1(2 bits), 2(4 bits), 3(8 bits), 4(16bits), 5(32 bits),
|
|
* 6(64 bits), 7(128 bits)
|
|
*/
|
|
static __inline__ uint64_t
|
|
nlm_crypto_form_pkt_ctrl_desc(unsigned int hmac, unsigned int hashalg,
|
|
unsigned int hashmode, unsigned int cipheralg, unsigned int ciphermode,
|
|
unsigned int arc4_cipherkeylen, unsigned int arc4_keyinit,
|
|
unsigned int cfbmask)
|
|
{
|
|
return (left_shift64(hmac, 61, 1) |
|
|
left_shift64(hashalg, 52, 8) |
|
|
left_shift64(hashmode, 43, 8) |
|
|
left_shift64(cipheralg, 34, 8) |
|
|
left_shift64(ciphermode, 25, 8) |
|
|
left_shift64(arc4_cipherkeylen, 18, 5) |
|
|
left_shift64(arc4_keyinit, 17, 1) |
|
|
left_shift64(cfbmask, 0, 3));
|
|
}
|
|
/**
|
|
* @brief Generate cypto packet descriptor 0
|
|
* @ingroup crypto
|
|
* tls : 1 (tls enabled) 0(tls disabled)
|
|
* hash_source : 1 (encrypted data is sent to the auth engine)
|
|
* 0 (plain data is sent to the auth engine)
|
|
* hashout_l3alloc : 1 (auth output is transited through l3 cache)
|
|
* encrypt : 1 (for encrypt) 0 (for decrypt)
|
|
* ivlen : iv length in bytes
|
|
* hashdst_addr : hash out physical address, byte aligned
|
|
*/
|
|
static __inline__ uint64_t
|
|
nlm_crypto_form_pkt_desc0(unsigned int tls, unsigned int hash_source,
|
|
unsigned int hashout_l3alloc, unsigned int encrypt, unsigned int ivlen,
|
|
uint64_t hashdst_addr)
|
|
{
|
|
return (left_shift64(tls, 63, 1) |
|
|
left_shift64(hash_source, 62, 1) |
|
|
left_shift64(hashout_l3alloc, 60, 1) |
|
|
left_shift64(encrypt, 59, 1) |
|
|
left_shift64_mask((ivlen - 1), 41, 16) |
|
|
left_shift64(hashdst_addr, 0, 40));
|
|
}
|
|
|
|
/**
|
|
* @brief Generate cypto packet descriptor 1
|
|
* @ingroup crypto
|
|
* cipherlen : cipher length in bytes
|
|
* hashlen : hash length in bytes
|
|
*/
|
|
static __inline__ uint64_t
|
|
nlm_crypto_form_pkt_desc1(unsigned int cipherlen, unsigned int hashlen)
|
|
{
|
|
return (left_shift64_mask((cipherlen - 1), 32, 32) |
|
|
left_shift64_mask((hashlen - 1), 0, 32));
|
|
}
|
|
|
|
/**
|
|
* @brief Generate cypto packet descriptor 2
|
|
* @ingroup crypto
|
|
* ivoff : iv offset, offset from start of src data addr
|
|
* ciperbit_cnt : number of valid bits in the last input byte to the cipher,
|
|
* 0 (8 bits), 1 (1 bit)..7 (7 bits)
|
|
* cipheroff : cipher offset, offset from start of src data addr
|
|
* hashbit_cnt : number of valid bits in the last input byte to the auth
|
|
* 0 (8 bits), 1 (1 bit)..7 (7 bits)
|
|
* hashclobber : 1 (hash output will be written as multiples of cachelines, no
|
|
* read modify write)
|
|
* hashoff : hash offset, offset from start of src data addr
|
|
*/
|
|
|
|
static __inline__ uint64_t
|
|
nlm_crypto_form_pkt_desc2(unsigned int ivoff, unsigned int cipherbit_cnt,
|
|
unsigned int cipheroff, unsigned int hashbit_cnt, unsigned int hashclobber,
|
|
unsigned int hashoff)
|
|
{
|
|
return (left_shift64(ivoff , 45, 16) |
|
|
left_shift64(cipherbit_cnt, 42, 3) |
|
|
left_shift64(cipheroff, 22, 16) |
|
|
left_shift64(hashbit_cnt, 19, 3) |
|
|
left_shift64(hashclobber, 18, 1) |
|
|
left_shift64(hashoff, 0, 16));
|
|
}
|
|
|
|
/**
|
|
* @brief Generate cypto packet descriptor 3
|
|
* @ingroup crypto
|
|
* designer_vc : designer freeback fmn destination id
|
|
* taglen : length in bits of the tag generated by the auth engine
|
|
* md5 (128 bits), sha1 (160), sha224 (224), sha384 (384),
|
|
* sha512 (512), Kasumi (32), snow3g (32), gcm (128)
|
|
* hmacpad : 1 if hmac padding is already done
|
|
*/
|
|
static __inline__ uint64_t
|
|
nlm_crypto_form_pkt_desc3(unsigned int designer_vc, unsigned int taglen,
|
|
unsigned int arc4_state_save_l3, unsigned int arc4_save_state,
|
|
unsigned int hmacpad)
|
|
{
|
|
return (left_shift64(designer_vc, 48, 16) |
|
|
left_shift64(taglen, 11, 16) |
|
|
left_shift64(arc4_state_save_l3, 8, 1) |
|
|
left_shift64(arc4_save_state, 6, 1) |
|
|
left_shift64(hmacpad, 5, 1));
|
|
}
|
|
|
|
/**
|
|
* @brief Generate cypto packet descriptor 4
|
|
* @ingroup crypto
|
|
* srcfraglen : length of the source fragment(header + data + tail) in bytes
|
|
* srcfragaddr : physical address of the srouce fragment
|
|
*/
|
|
static __inline__ uint64_t
|
|
nlm_crypto_form_pkt_desc4(uint64_t srcfraglen,
|
|
unsigned int srcfragaddr )
|
|
{
|
|
return (left_shift64_mask((srcfraglen - 1), 48, 16) |
|
|
left_shift64(srcfragaddr, 0, 40));
|
|
}
|
|
|
|
/**
|
|
* @brief Generate cypto packet descriptor 5
|
|
* @ingroup crypto
|
|
* dstfraglen : length of the dst fragment(header + data + tail) in bytes
|
|
* chipherout_l3alloc : 1(cipher output is transited through l3 cache)
|
|
* cipherclobber : 1 (cipher output will be written as multiples of cachelines,
|
|
* no read modify write)
|
|
* chiperdst_addr : physical address of the cipher destination address
|
|
*/
|
|
static __inline__ uint64_t
|
|
nlm_crypto_form_pkt_desc5(unsigned int dstfraglen,
|
|
unsigned int cipherout_l3alloc, unsigned int cipherclobber,
|
|
uint64_t cipherdst_addr)
|
|
|
|
{
|
|
return (left_shift64_mask((dstfraglen - 1), 48, 16) |
|
|
left_shift64(cipherout_l3alloc, 46, 1) |
|
|
left_shift64(cipherclobber, 41, 1) |
|
|
left_shift64(cipherdst_addr, 0, 40));
|
|
}
|
|
|
|
/**
|
|
* @brief Generate crypto packet fmn message entry 0
|
|
* @ingroup crypto
|
|
* freeback_vc: freeback response destination address
|
|
* designer_fblen : Designer freeback length, 1 - 4
|
|
* designerdesc_valid : designer desc valid or not
|
|
* cipher_keylen : cipher key length in bytes
|
|
* ctrldesc_addr : physicall address of the control descriptor
|
|
*/
|
|
static __inline__ uint64_t
|
|
nlm_crypto_form_pkt_fmn_entry0(unsigned int freeback_vc,
|
|
unsigned int designer_fblen, unsigned int designerdesc_valid,
|
|
unsigned int cipher_keylen, uint64_t cntldesc_addr)
|
|
{
|
|
return (left_shift64(freeback_vc, 48, 16) |
|
|
left_shift64_mask(designer_fblen - 1, 46, 2) |
|
|
left_shift64(designerdesc_valid, 45, 1) |
|
|
left_shift64_mask(((cipher_keylen + 7) >> 3), 40, 5) |
|
|
left_shift64(cntldesc_addr >> 6, 0, 34));
|
|
}
|
|
|
|
/**
|
|
* @brief Generate crypto packet fmn message entry 1
|
|
* @ingroup crypto
|
|
* arc4load_state : 1 if load state required 0 otherwise
|
|
* hash_keylen : hash key length in bytes
|
|
* pktdesc_size : packet descriptor size in bytes
|
|
* pktdesc_addr : physicall address of the packet descriptor
|
|
*/
|
|
static __inline__ uint64_t
|
|
nlm_crypto_form_pkt_fmn_entry1(unsigned int arc4load_state,
|
|
unsigned int hash_keylen, unsigned int pktdesc_size,
|
|
uint64_t pktdesc_addr)
|
|
{
|
|
return (left_shift64(arc4load_state, 63, 1) |
|
|
left_shift64_mask(((hash_keylen + 7) >> 3), 56, 5) |
|
|
left_shift64_mask(((pktdesc_size >> 4) - 1), 43, 12) |
|
|
left_shift64(pktdesc_addr >> 6, 0, 34));
|
|
}
|
|
|
|
static __inline__ int
|
|
nlm_crypto_get_hklen_taglen(enum nlm_hash_algo hashalg,
|
|
enum nlm_hash_mode hashmode, unsigned int *taglen, unsigned int *hklen)
|
|
{
|
|
if (hashalg == NLM_HASH_MD5) {
|
|
*taglen = 128;
|
|
*hklen = 64;
|
|
} else if (hashalg == NLM_HASH_SHA) {
|
|
switch (hashmode) {
|
|
case NLM_HASH_MODE_SHA1:
|
|
*taglen = 160;
|
|
*hklen = 64;
|
|
break;
|
|
case NLM_HASH_MODE_SHA224:
|
|
*taglen = 224;
|
|
*hklen = 64;
|
|
break;
|
|
case NLM_HASH_MODE_SHA256:
|
|
*taglen = 256;
|
|
*hklen = 64;
|
|
break;
|
|
case NLM_HASH_MODE_SHA384:
|
|
*taglen = 384;
|
|
*hklen = 128;
|
|
break;
|
|
case NLM_HASH_MODE_SHA512:
|
|
*taglen = 512;
|
|
*hklen = 128;
|
|
break;
|
|
default:
|
|
printf("Error : invalid shaid (%s)\n", __func__);
|
|
return (-1);
|
|
}
|
|
} else if (hashalg == NLM_HASH_KASUMI_F9) {
|
|
*taglen = 32;
|
|
*hklen = 0;
|
|
} else if (hashalg == NLM_HASH_SNOW3G_F9) {
|
|
*taglen = 32;
|
|
*hklen = 0;
|
|
} else if (hashmode == NLM_HASH_MODE_XCBC) {
|
|
*taglen = 128;
|
|
*hklen = 0;
|
|
} else if (hashmode == NLM_HASH_MODE_GCM) {
|
|
*taglen = 128;
|
|
*hklen = 0;
|
|
} else if (hashalg == NLM_HASH_BYPASS) {
|
|
*taglen = 0;
|
|
*hklen = 0;
|
|
} else {
|
|
printf("Error:Hash alg/mode not found\n");
|
|
return (-1);
|
|
}
|
|
|
|
/* TODO : Add remaining cases */
|
|
return (0);
|
|
}
|
|
|
|
/**
|
|
* @brief Generate fill cryto control info structure
|
|
* @ingroup crypto
|
|
* hmac : 1 for hash with hmac
|
|
* hashalg: see above, hash_alg enums
|
|
* hashmode: see above, hash_mode enums
|
|
* cipherhalg: see above, cipher_alg enums
|
|
* ciphermode: see above, cipher_mode enums
|
|
*
|
|
*/
|
|
static __inline__ int
|
|
nlm_crypto_fill_pkt_ctrl(struct nlm_crypto_pkt_ctrl *ctrl, unsigned int hmac,
|
|
enum nlm_hash_algo hashalg, enum nlm_hash_mode hashmode,
|
|
enum nlm_cipher_algo cipheralg, enum nlm_cipher_mode ciphermode,
|
|
unsigned char *cipherkey, unsigned int cipherkeylen,
|
|
unsigned char *hashkey, unsigned int hashkeylen)
|
|
{
|
|
unsigned int taglen = 0, hklen = 0;
|
|
|
|
ctrl->desc0 = nlm_crypto_form_pkt_ctrl_desc(hmac, hashalg, hashmode,
|
|
cipheralg, ciphermode, 0, 0, 0);
|
|
memset(ctrl->key, 0, sizeof(ctrl->key));
|
|
if (cipherkey)
|
|
memcpy(ctrl->key, cipherkey, cipherkeylen);
|
|
if (hashkey)
|
|
memcpy((unsigned char *)&ctrl->key[(cipherkeylen + 7) / 8],
|
|
hashkey, hashkeylen);
|
|
if (nlm_crypto_get_hklen_taglen(hashalg, hashmode, &taglen, &hklen)
|
|
< 0)
|
|
return (-1);
|
|
|
|
ctrl->cipherkeylen = cipherkeylen;
|
|
ctrl->hashkeylen = hklen;
|
|
ctrl->taglen = taglen;
|
|
|
|
/* TODO : add the invalid checks and return error */
|
|
return (0);
|
|
}
|
|
|
|
/**
|
|
* @brief Top level function for generation pkt desc 0 to 3 for cipher auth
|
|
* @ingroup crypto
|
|
* ctrl : pointer to control structure
|
|
* param : pointer to the param structure
|
|
* encrypt : 1(for encrypt) 0(for decrypt)
|
|
* hash_source : 1(encrypted data is sent to the auth engine) 0(plain data is
|
|
* sent to the auth engine)
|
|
* ivoff : iv offset from start of data
|
|
* ivlen : iv length in bytes
|
|
* hashoff : hash offset from start of data
|
|
* hashlen : hash length in bytes
|
|
* hmacpad : hmac padding required or not, 1 if already padded
|
|
* cipheroff : cipher offset from start of data
|
|
* cipherlen : cipher length in bytes
|
|
* hashdst_addr : hash destination physical address
|
|
*/
|
|
static __inline__ void
|
|
nlm_crypto_fill_cipher_auth_pkt_param(struct nlm_crypto_pkt_ctrl *ctrl,
|
|
struct nlm_crypto_pkt_param *param, unsigned int encrypt,
|
|
unsigned int hash_source, unsigned int ivoff, unsigned int ivlen,
|
|
unsigned int hashoff, unsigned int hashlen, unsigned int hmacpad,
|
|
unsigned int cipheroff, unsigned int cipherlen, unsigned char *hashdst_addr)
|
|
{
|
|
param->desc0 = nlm_crypto_form_pkt_desc0(0, hash_source, 1, encrypt,
|
|
ivlen, vtophys(hashdst_addr));
|
|
param->desc1 = nlm_crypto_form_pkt_desc1(cipherlen, hashlen);
|
|
param->desc2 = nlm_crypto_form_pkt_desc2(ivoff, 0, cipheroff, 0, 0,
|
|
hashoff);
|
|
param->desc3 = nlm_crypto_form_pkt_desc3(0, ctrl->taglen, 0, 0,
|
|
hmacpad);
|
|
}
|
|
|
|
/**
|
|
* @brief Top level function for generation pkt desc 0 to 3 for cipher operation
|
|
* @ingroup crypto
|
|
* ctrl : pointer to control structure
|
|
* param : pointer to the param structure
|
|
* encrypt : 1(for encrypt) 0(for decrypt)
|
|
* ivoff : iv offset from start of data
|
|
* ivlen : iv length in bytes
|
|
* cipheroff : cipher offset from start of data
|
|
* cipherlen : cipher length in bytes
|
|
*/
|
|
static __inline__ void
|
|
nlm_crypto_fill_cipher_pkt_param(struct nlm_crypto_pkt_ctrl *ctrl,
|
|
struct nlm_crypto_pkt_param *param, unsigned int encrypt,
|
|
unsigned int ivoff, unsigned int ivlen, unsigned int cipheroff,
|
|
unsigned int cipherlen)
|
|
{
|
|
param->desc0 = nlm_crypto_form_pkt_desc0(0, 0, 0, encrypt, ivlen, 0ULL);
|
|
param->desc1 = nlm_crypto_form_pkt_desc1(cipherlen, 1);
|
|
param->desc2 = nlm_crypto_form_pkt_desc2(ivoff, 0, cipheroff, 0, 0, 0);
|
|
param->desc3 = nlm_crypto_form_pkt_desc3(0, ctrl->taglen, 0, 0, 0);
|
|
}
|
|
|
|
/**
|
|
* @brief Top level function for generation pkt desc 0 to 3 for auth operation
|
|
* @ingroup crypto
|
|
* ctrl : pointer to control structure
|
|
* param : pointer to the param structure
|
|
* hashoff : hash offset from start of data
|
|
* hashlen : hash length in bytes
|
|
* hmacpad : hmac padding required or not, 1 if already padded
|
|
* hashdst_addr : hash destination physical address
|
|
*/
|
|
static __inline__ void
|
|
nlm_crypto_fill_auth_pkt_param(struct nlm_crypto_pkt_ctrl *ctrl,
|
|
struct nlm_crypto_pkt_param *param, unsigned int hashoff,
|
|
unsigned int hashlen, unsigned int hmacpad, unsigned char *hashdst_addr)
|
|
{
|
|
param->desc0 = nlm_crypto_form_pkt_desc0(0, 0, 1, 0, 1,
|
|
vtophys(hashdst_addr));
|
|
param->desc1 = nlm_crypto_form_pkt_desc1(1, hashlen);
|
|
param->desc2 = nlm_crypto_form_pkt_desc2(0, 0, 0, 0, 0, hashoff);
|
|
param->desc3 = nlm_crypto_form_pkt_desc3(0, ctrl->taglen, 0, 0,
|
|
hmacpad);
|
|
}
|
|
|
|
static __inline__ unsigned int
|
|
nlm_crypto_fill_src_seg(struct nlm_crypto_pkt_param *param, int seg,
|
|
unsigned char *input, unsigned int inlen)
|
|
{
|
|
unsigned off = 0, len = 0;
|
|
unsigned int remlen = inlen;
|
|
|
|
for (; remlen > 0;) {
|
|
len = remlen > NLM_CRYPTO_MAX_SEG_LEN ?
|
|
NLM_CRYPTO_MAX_SEG_LEN : remlen;
|
|
param->segment[seg][0] = nlm_crypto_form_pkt_desc4(len,
|
|
vtophys(input + off));
|
|
remlen -= len;
|
|
off += len;
|
|
seg++;
|
|
}
|
|
return (seg);
|
|
}
|
|
|
|
static __inline__ unsigned int
|
|
nlm_crypto_fill_dst_seg(struct nlm_crypto_pkt_param *param,
|
|
int seg, unsigned char *output, unsigned int outlen)
|
|
{
|
|
unsigned off = 0, len = 0;
|
|
unsigned int remlen = outlen;
|
|
|
|
for (; remlen > 0;) {
|
|
len = remlen > NLM_CRYPTO_MAX_SEG_LEN ?
|
|
NLM_CRYPTO_MAX_SEG_LEN : remlen;
|
|
param->segment[seg][1] = nlm_crypto_form_pkt_desc5(len, 1, 0,
|
|
vtophys(output + off));
|
|
remlen -= len;
|
|
off += len;
|
|
seg++;
|
|
}
|
|
return (seg);
|
|
}
|
|
|
|
#endif
|