3175 lines
110 KiB
C
3175 lines
110 KiB
C
/*-
|
|
* Copyright (c) 2003-2009 RMI 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.
|
|
* 3. Neither the name of RMI Corporation, nor the names of its contributors,
|
|
* may be used to endorse or promote products derived from this software
|
|
* without specific prior written permission.
|
|
*
|
|
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``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 THE AUTHOR 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.
|
|
*
|
|
* RMI_BSD
|
|
*/
|
|
|
|
#include <sys/cdefs.h>
|
|
__FBSDID("$FreeBSD$");
|
|
|
|
#include <sys/param.h>
|
|
#include <sys/types.h>
|
|
#include <sys/systm.h>
|
|
#include <sys/kernel.h>
|
|
#include <sys/module.h>
|
|
#include <sys/malloc.h>
|
|
#include <sys/bus.h>
|
|
#include <machine/bus.h>
|
|
#include <machine/md_var.h>
|
|
#include <machine/mips-exts.h>
|
|
#include <machine/cpuregs.h>
|
|
|
|
#include <vm/vm.h>
|
|
#include <vm/pmap.h>
|
|
|
|
#include <opencrypto/cryptodev.h>
|
|
|
|
|
|
#include <mips/xlr/iomap.h>
|
|
#include <mips/xlr/pic.h>
|
|
#include <mips/xlr/shared_structs.h>
|
|
#include <mips/xlr/iomap.h>
|
|
#include <mips/xlr/msgring.h>
|
|
#include <mips/xlr/board.h>
|
|
#include <mips/rmi/dev/sec/rmilib.h>
|
|
#include <mips/rmi/dev/sec/desc.h>
|
|
|
|
|
|
// static int msgrng_stnid_pk0 = MSGRNG_STNID_PK0;
|
|
|
|
/*#define RMI_SEC_DEBUG */
|
|
|
|
#define SMP_CACHE_BYTES XLR_CACHELINE_SIZE
|
|
#define NUM_CHUNKS(size, bits) ( ((size)>>(bits)) + (((size)&((1<<(bits))-1))?1:0) )
|
|
|
|
static const char nib2hex[] = "0123456789ABCDEF";
|
|
symkey_desc_pt g_desc;
|
|
struct xlr_sec_command *g_cmd;
|
|
|
|
#ifdef XLR_SEC_CMD_DEBUG
|
|
static void
|
|
decode_symkey_desc(symkey_desc_pt desc, uint32_t cfg_vector);
|
|
|
|
#endif
|
|
|
|
void print_buf(char *desc, void *data, int len);
|
|
|
|
static int
|
|
xlr_sec_cipher_hash_command(xlr_sec_io_pt op, symkey_desc_pt desc, uint8_t);
|
|
|
|
static xlr_sec_error_t
|
|
xlr_sec_setup_descriptor(xlr_sec_io_pt op,
|
|
unsigned int flags,
|
|
symkey_desc_pt desc,
|
|
uint32_t * cfg_vector);
|
|
|
|
static
|
|
xlr_sec_error_t
|
|
xlr_sec_setup_packet(xlr_sec_io_pt op,
|
|
symkey_desc_pt desc,
|
|
unsigned int flags,
|
|
uint64_t * data,
|
|
PacketDescriptor_pt pkt_desc,
|
|
ControlDescriptor_pt ctl_desc,
|
|
uint32_t vector,
|
|
PacketDescriptor_pt next_pkt_desc,
|
|
uint8_t multi_frag_flag);
|
|
|
|
static int
|
|
xlr_sec_submit_message(symkey_desc_pt desc, uint32_t cfg_vector);
|
|
|
|
static
|
|
xlr_sec_error_t
|
|
xlr_sec_setup_cipher(xlr_sec_io_pt op,
|
|
ControlDescriptor_pt ctl_desc,
|
|
uint32_t * vector);
|
|
|
|
static
|
|
xlr_sec_error_t
|
|
xlr_sec_setup_digest(xlr_sec_io_pt op,
|
|
ControlDescriptor_pt ctl_desc,
|
|
uint32_t * vector);
|
|
|
|
static
|
|
xlr_sec_error_t
|
|
xlr_sec_setup_cksum(xlr_sec_io_pt op,
|
|
ControlDescriptor_pt ctl_desc);
|
|
|
|
static
|
|
xlr_sec_error_t
|
|
xlr_sec_control_setup(xlr_sec_io_pt op,
|
|
unsigned int flags,
|
|
uint64_t * control,
|
|
ControlDescriptor_pt ctl_desc,
|
|
xlr_sec_drv_user_t * user,
|
|
uint32_t vector);
|
|
|
|
|
|
xlr_sec_error_t
|
|
xlr_sec_submit_op(symkey_desc_pt desc);
|
|
|
|
static void xlr_sec_free_desc(symkey_desc_pt desc);
|
|
|
|
void
|
|
xlr_sec_msgring_handler(int bucket, int size, int code, int stid,
|
|
struct msgrng_msg *msg, void *data);
|
|
|
|
|
|
void
|
|
xlr_sec_init(struct xlr_sec_softc *sc)
|
|
{
|
|
unsigned int i;
|
|
xlr_reg_t *mmio;
|
|
|
|
|
|
mmio = sc->mmio = xlr_io_mmio(XLR_IO_SECURITY_OFFSET);
|
|
|
|
xlr_write_reg(mmio, SEC_DMA_CREDIT, SEC_DMA_CREDIT_CONFIG);
|
|
|
|
|
|
xlr_write_reg(mmio, SEC_CONFIG2, SEC_CFG2_ROUND_ROBIN_ON);
|
|
|
|
for (i = 0; i < 8; i++)
|
|
xlr_write_reg(mmio,
|
|
SEC_MSG_BUCKET0_SIZE + i,
|
|
xlr_is_xls() ?
|
|
xls_bucket_sizes.bucket[MSGRNG_STNID_SEC + i] :
|
|
bucket_sizes.bucket[MSGRNG_STNID_SEC + i]);
|
|
|
|
for (i = 0; i < 128; i++)
|
|
xlr_write_reg(mmio,
|
|
SEC_CC_CPU0_0 + i,
|
|
xlr_is_xls() ?
|
|
xls_cc_table_sec.counters[i >> 3][i & 0x07] :
|
|
cc_table_sec.counters[i >> 3][i & 0x07]);
|
|
|
|
|
|
/*
|
|
* Register a bucket handler with the phoenix messaging subsystem
|
|
* For now, register handler for bucket 0->5 in msg stn 0
|
|
*/
|
|
if (register_msgring_handler(TX_STN_SAE, xlr_sec_msgring_handler, NULL)) {
|
|
panic("Couldn't register msgring handler 0\n");
|
|
}
|
|
return;
|
|
}
|
|
|
|
|
|
|
|
int
|
|
xlr_sec_setup(struct xlr_sec_session *ses,
|
|
struct xlr_sec_command *cmd,
|
|
symkey_desc_pt desc
|
|
)
|
|
{
|
|
xlr_sec_io_pt op;
|
|
int size, ret_val;
|
|
int iv_len;
|
|
|
|
|
|
desc->ses = ses;
|
|
op = &cmd->op;
|
|
if (op == NULL)
|
|
return (-ENOMEM);
|
|
|
|
|
|
|
|
desc->ctl_desc.instruction = 0;
|
|
memset(&desc->ctl_desc.cipherHashInfo, 0, sizeof(CipherHashInfo_t));
|
|
desc->control = 0;
|
|
|
|
desc->pkt_desc[0].srcLengthIVOffUseIVNext = 0;
|
|
desc->pkt_desc[0].dstDataSettings = 0;
|
|
desc->pkt_desc[0].authDstNonceLow = 0;
|
|
desc->pkt_desc[0].ckSumDstNonceHiCFBMaskLLWMask = 0;
|
|
desc->pkt_desc[1].srcLengthIVOffUseIVNext = 0;
|
|
desc->pkt_desc[1].dstDataSettings = 0;
|
|
desc->pkt_desc[1].authDstNonceLow = 0;
|
|
desc->pkt_desc[1].ckSumDstNonceHiCFBMaskLLWMask = 0;
|
|
|
|
desc->data = 0;
|
|
desc->ctl_result = 0;
|
|
desc->data_result = 0;
|
|
|
|
|
|
if (op->flags & XLR_SEC_FLAGS_HIGH_PRIORITY)
|
|
if (!xlr_is_xls())
|
|
desc->op_ctl.stn_id++;
|
|
|
|
desc->user.user_src = (uint8_t *) (unsigned long)op->source_buf;
|
|
desc->user.user_dest = (uint8_t *) (unsigned long)op->dest_buf;
|
|
desc->user.user_auth = (uint8_t *) (unsigned long)op->auth_dest;
|
|
|
|
|
|
if ((op->cipher_type == XLR_SEC_CIPHER_TYPE_ARC4) &&
|
|
(!op->rc4_state && (op->rc4_loadstate || op->rc4_savestate))) {
|
|
printf(" ** Load/Save State and no State **");
|
|
xlr_sec_free_desc(desc);
|
|
return (-EINVAL);
|
|
}
|
|
desc->user.user_state = (uint8_t *) (unsigned long)op->rc4_state;
|
|
|
|
|
|
switch (op->cipher_type) {
|
|
case XLR_SEC_CIPHER_TYPE_NONE:
|
|
iv_len = 0;
|
|
break;
|
|
case XLR_SEC_CIPHER_TYPE_DES:
|
|
case XLR_SEC_CIPHER_TYPE_3DES:
|
|
iv_len = XLR_SEC_DES_IV_LENGTH;
|
|
break;
|
|
case XLR_SEC_CIPHER_TYPE_AES128:
|
|
case XLR_SEC_CIPHER_TYPE_AES192:
|
|
case XLR_SEC_CIPHER_TYPE_AES256:
|
|
iv_len = XLR_SEC_AES_IV_LENGTH;
|
|
break;
|
|
case XLR_SEC_CIPHER_TYPE_ARC4:
|
|
iv_len = XLR_SEC_ARC4_IV_LENGTH;
|
|
break;
|
|
case XLR_SEC_CIPHER_TYPE_KASUMI_F8:
|
|
iv_len = XLR_SEC_KASUMI_F8_IV_LENGTH;
|
|
break;
|
|
|
|
default:
|
|
printf(" ** Undefined Cipher Type **");
|
|
xlr_sec_free_desc(desc);
|
|
return (-EINVAL);
|
|
}
|
|
|
|
|
|
|
|
|
|
size = op->source_buf_size + iv_len;
|
|
|
|
/*
|
|
* make sure that there are enough bytes for aes based stream
|
|
* ciphers
|
|
*/
|
|
if (op->cipher_mode == XLR_SEC_CIPHER_MODE_F8 ||
|
|
op->cipher_mode == XLR_SEC_CIPHER_MODE_CTR)
|
|
size += XLR_SEC_AES_BLOCK_SIZE - 1;
|
|
|
|
if (op->cipher_type == XLR_SEC_CIPHER_TYPE_NONE) {
|
|
if (op->source_buf_size != 0) {
|
|
memcpy(desc->user.aligned_src, (uint8_t *) (unsigned long)op->source_buf,
|
|
op->source_buf_size);
|
|
}
|
|
} else {
|
|
if (ses->multi_frag_flag) {
|
|
/* copy IV into temporary kernel source buffer */
|
|
memcpy(desc->user.aligned_src, &op->initial_vector[0], iv_len);
|
|
|
|
/* copy input data to temporary kernel source buffer */
|
|
memcpy((uint8_t *) (desc->user.aligned_src + iv_len),
|
|
(uint8_t *) (unsigned long)op->source_buf, SEC_MAX_FRAG_LEN);
|
|
|
|
desc->next_src_len = op->source_buf_size - SEC_MAX_FRAG_LEN;
|
|
memcpy((uint8_t *) (desc->next_src_buf),
|
|
(uint8_t *) (unsigned long)(op->source_buf + SEC_MAX_FRAG_LEN),
|
|
desc->next_src_len);
|
|
|
|
op->source_buf_size = SEC_MAX_FRAG_LEN;
|
|
op->source_buf_size += iv_len;
|
|
} else {
|
|
/* copy IV into temporary kernel source buffer */
|
|
memcpy(desc->user.aligned_src, &op->initial_vector[0], iv_len);
|
|
|
|
/* copy input data to temporary kernel source buffer */
|
|
memcpy((uint8_t *) (desc->user.aligned_src + iv_len),
|
|
(uint8_t *) (unsigned long)op->source_buf, op->source_buf_size);
|
|
op->source_buf_size += iv_len;
|
|
}
|
|
}
|
|
|
|
|
|
|
|
/* Set source to new kernel space */
|
|
op->source_buf = (uint64_t) (unsigned long)desc->user.aligned_src;
|
|
|
|
|
|
/*
|
|
* Build new dest buffer, for Cipher output only
|
|
*/
|
|
if (op->cipher_type == XLR_SEC_CIPHER_TYPE_NONE) {
|
|
/*
|
|
* Digest Engine *NEEDS* this, otherwise it will write at
|
|
* 0[x]
|
|
*/
|
|
op->dest_buf = (uint64_t) (unsigned long)desc->user.aligned_src;
|
|
} else {
|
|
/* DEBUG -dpk */
|
|
XLR_SEC_CMD_DIAG("dest_buf_size = %d \n", op->dest_buf_size);
|
|
|
|
size = op->dest_buf_size + iv_len;
|
|
|
|
/*
|
|
* make sure that there are enough bytes for aes based
|
|
* stream ciphers
|
|
*/
|
|
if (op->cipher_mode == XLR_SEC_CIPHER_MODE_F8 ||
|
|
op->cipher_mode == XLR_SEC_CIPHER_MODE_CTR)
|
|
size += XLR_SEC_AES_BLOCK_SIZE - 1;
|
|
op->dest_buf = (uint64_t) (unsigned long)desc->user.aligned_dest;
|
|
|
|
}
|
|
|
|
ret_val = xlr_sec_cipher_hash_command(op, desc, ses->multi_frag_flag);
|
|
|
|
return (ret_val);
|
|
|
|
}
|
|
|
|
static int
|
|
xlr_sec_cipher_hash_command(xlr_sec_io_pt op, symkey_desc_pt desc,
|
|
uint8_t multi_frag_flag)
|
|
{
|
|
xlr_sec_error_t err;
|
|
uint32_t cfg_vector;
|
|
unsigned int setup_flags = 0;
|
|
|
|
err = XLR_SEC_ERR_NONE;
|
|
cfg_vector = 0;
|
|
|
|
if ((op->digest_type == XLR_SEC_DIGEST_TYPE_NONE) &&
|
|
(op->cipher_type != XLR_SEC_CIPHER_TYPE_ARC4) &&
|
|
(op->cipher_mode != XLR_SEC_CIPHER_MODE_F8) &&
|
|
(op->cipher_type != XLR_SEC_CIPHER_TYPE_KASUMI_F8) &&
|
|
(op->source_buf_size & 0x7)) {
|
|
printf("Invalid Cipher Block Size, data len=%d\n",
|
|
op->source_buf_size);
|
|
return (-EINVAL);
|
|
}
|
|
do {
|
|
|
|
if ((op->cipher_type == XLR_SEC_CIPHER_TYPE_3DES) &&
|
|
(op->cipher_op == XLR_SEC_CIPHER_OP_DECRYPT))
|
|
setup_flags = XLR_SEC_SETUP_OP_FLIP_3DES_KEY;
|
|
|
|
err = xlr_sec_setup_descriptor(op,
|
|
setup_flags,
|
|
desc, &cfg_vector);
|
|
if (err != XLR_SEC_ERR_NONE)
|
|
break;
|
|
|
|
err = xlr_sec_setup_packet(op,
|
|
desc,
|
|
op->digest_type != XLR_SEC_DIGEST_TYPE_NONE ?
|
|
XLR_SEC_SETUP_OP_CIPHER_HMAC : 0,
|
|
&desc->data,
|
|
&desc->pkt_desc[0],
|
|
&desc->ctl_desc,
|
|
cfg_vector,
|
|
&desc->pkt_desc[1],
|
|
multi_frag_flag);
|
|
if (err != XLR_SEC_ERR_NONE)
|
|
break;
|
|
} while (0);
|
|
if (err != XLR_SEC_ERR_NONE) {
|
|
return (EINVAL);
|
|
}
|
|
err = xlr_sec_submit_message(desc, cfg_vector);
|
|
return err;
|
|
}
|
|
|
|
|
|
static xlr_sec_error_t
|
|
xlr_sec_setup_descriptor(xlr_sec_io_pt op,
|
|
unsigned int flags,
|
|
symkey_desc_pt desc,
|
|
uint32_t * cfg_vector)
|
|
{
|
|
xlr_sec_error_t err;
|
|
|
|
XLR_SEC_CMD_DIAG("xlr_sec_setup_descriptor: ENTER\n");
|
|
|
|
|
|
if ((err = xlr_sec_setup_cipher(op, &desc->ctl_desc, cfg_vector)) != XLR_SEC_ERR_NONE) {
|
|
XLR_SEC_CMD_DIAG("xlr_sec_setup_descriptor: xlr_sec_setup_cipher done err %d\n",
|
|
(int)err);
|
|
return err;
|
|
}
|
|
if (op->digest_type != XLR_SEC_DIGEST_TYPE_NONE) {
|
|
if ((err = xlr_sec_setup_digest(op, &desc->ctl_desc, cfg_vector)) != XLR_SEC_ERR_NONE) {
|
|
XLR_SEC_CMD_DIAG("xlr_sec_setup_descriptor: xlr_sec_setup_digest done err %d\n",
|
|
(int)err);
|
|
return err;
|
|
}
|
|
}
|
|
if ((err = xlr_sec_setup_cksum(op, &desc->ctl_desc)) != XLR_SEC_ERR_NONE) {
|
|
XLR_SEC_CMD_DIAG("xlr_sec_setup_descriptor: xlr_sec_setup_cksum done err %d\n",
|
|
(int)err);
|
|
return err;
|
|
}
|
|
if ((err = xlr_sec_control_setup(op,
|
|
flags,
|
|
&desc->control,
|
|
&desc->ctl_desc,
|
|
&desc->user,
|
|
*cfg_vector)) != XLR_SEC_ERR_NONE) {
|
|
XLR_SEC_CMD_DIAG("xlr_sec_setup_descriptor: xlr_sec_control_setup done err %d\n",
|
|
(int)err);
|
|
return err;
|
|
}
|
|
XLR_SEC_CMD_DIAG("xlr_sec_setup_descriptor: DONE\n");
|
|
return err;
|
|
}
|
|
|
|
|
|
|
|
static
|
|
xlr_sec_error_t
|
|
xlr_sec_setup_packet(xlr_sec_io_pt op,
|
|
symkey_desc_pt desc,
|
|
unsigned int flags,
|
|
uint64_t * data,
|
|
PacketDescriptor_pt pkt_desc,
|
|
ControlDescriptor_pt ctl_desc,
|
|
uint32_t vector,
|
|
PacketDescriptor_pt next_pkt_desc,
|
|
uint8_t multi_frag_flag)
|
|
{
|
|
uint32_t len, next_len = 0, len_dwords, last_u64_bytes;
|
|
uint64_t addr;
|
|
uint64_t seg_addr, next_seg_addr = 0;
|
|
uint64_t byte_offset, global_offset;
|
|
uint32_t cipher_offset_dwords;
|
|
|
|
XLR_SEC_CMD_DIAG("xlr_sec_setup_packet: ENTER vector = %04x\n", vector);
|
|
|
|
/* physical address of the source buffer */
|
|
addr = (uint64_t) vtophys((void *)(unsigned long)op->source_buf);
|
|
/* cache-aligned base of the source buffer */
|
|
seg_addr = (addr & ~(SMP_CACHE_BYTES - 1));
|
|
/* offset in bytes to the source buffer start from the segment base */
|
|
byte_offset = addr - seg_addr;
|
|
/* global offset: 0-7 bytes */
|
|
global_offset = byte_offset & 0x7;
|
|
|
|
|
|
/*
|
|
* op->source_buf_size is expected to be the Nb double words to
|
|
* stream in (Including Segment address->CP/IV/Auth/CkSum offsets)
|
|
*/
|
|
|
|
/*
|
|
* adjusted length of the whole thing, accounting for the added
|
|
* head, sans global_offset (per Paul S.)
|
|
*/
|
|
|
|
len = op->source_buf_size + byte_offset - global_offset;
|
|
if (multi_frag_flag) {
|
|
next_seg_addr = (uint64_t) vtophys((void *)(unsigned long)(desc->next_src_buf));
|
|
next_seg_addr = (next_seg_addr & ~(SMP_CACHE_BYTES - 1));
|
|
next_len = desc->next_src_len;
|
|
}
|
|
/* length of the whole thing in dwords */
|
|
len_dwords = NUM_CHUNKS(len, 3);
|
|
/* number of bytes in the last chunk (len % 8) */
|
|
last_u64_bytes = len & 0x07;
|
|
|
|
if (op->cipher_offset & 0x7) {
|
|
printf("** cipher_offset(%d) fails 64-bit word alignment **",
|
|
op->cipher_offset);
|
|
|
|
return XLR_SEC_ERR_CIPHER_MODE; /* ! fix ! */
|
|
}
|
|
/*
|
|
* global_offset is only three bits, so work the number of the whole
|
|
* 8-byte words into the global offset. both offset and
|
|
* cipher_offset are byte counts
|
|
*/
|
|
cipher_offset_dwords = (op->iv_offset + byte_offset) >> 3;
|
|
|
|
|
|
if (op->cipher_mode == XLR_SEC_CIPHER_MODE_F8 ||
|
|
op->cipher_mode == XLR_SEC_CIPHER_MODE_CTR) {
|
|
if (multi_frag_flag) {
|
|
int nlhmac = ((op->source_buf_size + global_offset + 7 - op->cipher_offset) >> 3) & 1;
|
|
|
|
pkt_desc->srcLengthIVOffUseIVNext =
|
|
|
|
FIELD_VALUE(PKT_DSC_HASHBYTES, len & 7) |
|
|
FIELD_VALUE(PKT_DSC_IVOFF, cipher_offset_dwords) |
|
|
FIELD_VALUE(PKT_DSC_PKTLEN, nlhmac + ((len + 7) >> 3)) |
|
|
FIELD_VALUE(PKT_DSC_NLHMAC, nlhmac) |
|
|
FIELD_VALUE(PKT_DSC_BREAK, 0) |
|
|
FIELD_VALUE(PKT_DSC_WAIT, 1) |
|
|
FIELD_VALUE(PKT_DSC_NEXT, 1) |
|
|
FIELD_VALUE(PKT_DSC_SEGADDR, seg_addr >> (PKT_DSC_SEGADDR_LSB)) |
|
|
FIELD_VALUE(PKT_DSC_SEGOFFSET, global_offset);
|
|
} else {
|
|
int nlhmac = ((op->source_buf_size + global_offset + 7 - op->cipher_offset) >> 3) & 1;
|
|
|
|
pkt_desc->srcLengthIVOffUseIVNext =
|
|
FIELD_VALUE(PKT_DSC_HASHBYTES, len & 7) |
|
|
FIELD_VALUE(PKT_DSC_IVOFF, cipher_offset_dwords) |
|
|
FIELD_VALUE(PKT_DSC_PKTLEN, nlhmac + ((len + 7) >> 3)) |
|
|
FIELD_VALUE(PKT_DSC_NLHMAC, nlhmac) |
|
|
FIELD_VALUE(PKT_DSC_BREAK, 0) |
|
|
FIELD_VALUE(PKT_DSC_WAIT, 0) |
|
|
FIELD_VALUE(PKT_DSC_SEGADDR, seg_addr >> (PKT_DSC_SEGADDR_LSB)) |
|
|
FIELD_VALUE(PKT_DSC_SEGOFFSET, global_offset);
|
|
|
|
}
|
|
} else {
|
|
if (multi_frag_flag) {
|
|
pkt_desc->srcLengthIVOffUseIVNext =
|
|
|
|
FIELD_VALUE(PKT_DSC_HASHBYTES, len & 7) |
|
|
FIELD_VALUE(PKT_DSC_IVOFF, cipher_offset_dwords) |
|
|
FIELD_VALUE(PKT_DSC_PKTLEN, (len + 7) >> 3) |
|
|
FIELD_VALUE(PKT_DSC_BREAK, 0) |
|
|
FIELD_VALUE(PKT_DSC_WAIT, 0) |
|
|
FIELD_VALUE(PKT_DSC_NEXT, 1) |
|
|
FIELD_VALUE(PKT_DSC_SEGADDR, seg_addr >> (PKT_DSC_SEGADDR_LSB)) |
|
|
FIELD_VALUE(PKT_DSC_SEGOFFSET, global_offset);
|
|
|
|
|
|
next_pkt_desc->srcLengthIVOffUseIVNext =
|
|
FIELD_VALUE(PKT_DSC_HASHBYTES, (next_len & 7)) |
|
|
FIELD_VALUE(PKT_DSC_IVOFF, 0) |
|
|
FIELD_VALUE(PKT_DSC_PKTLEN, (next_len + 7) >> 3) |
|
|
FIELD_VALUE(PKT_DSC_BREAK, 0) |
|
|
FIELD_VALUE(PKT_DSC_WAIT, 0) |
|
|
FIELD_VALUE(PKT_DSC_NEXT, 0) |
|
|
FIELD_VALUE(PKT_DSC_SEGADDR, next_seg_addr >> (PKT_DSC_SEGADDR_LSB)) |
|
|
FIELD_VALUE(PKT_DSC_SEGOFFSET, 0);
|
|
|
|
|
|
} else {
|
|
pkt_desc->srcLengthIVOffUseIVNext =
|
|
FIELD_VALUE(PKT_DSC_HASHBYTES, len & 7) |
|
|
FIELD_VALUE(PKT_DSC_IVOFF, cipher_offset_dwords) |
|
|
FIELD_VALUE(PKT_DSC_PKTLEN, (len + 7) >> 3) |
|
|
FIELD_VALUE(PKT_DSC_BREAK, 0) |
|
|
FIELD_VALUE(PKT_DSC_WAIT, 0) |
|
|
FIELD_VALUE(PKT_DSC_SEGADDR, seg_addr >> (PKT_DSC_SEGADDR_LSB)) |
|
|
FIELD_VALUE(PKT_DSC_SEGOFFSET, global_offset);
|
|
|
|
|
|
}
|
|
}
|
|
|
|
switch (op->pkt_hmac) {
|
|
case XLR_SEC_LOADHMACKEY_MODE_OLD:
|
|
CLEAR_SET_FIELD(pkt_desc->srcLengthIVOffUseIVNext,
|
|
PKT_DSC_LOADHMACKEY, PKT_DSC_LOADHMACKEY_OLD);
|
|
if (multi_frag_flag) {
|
|
CLEAR_SET_FIELD(next_pkt_desc->srcLengthIVOffUseIVNext,
|
|
PKT_DSC_LOADHMACKEY, PKT_DSC_LOADHMACKEY_OLD);
|
|
|
|
}
|
|
break;
|
|
case XLR_SEC_LOADHMACKEY_MODE_LOAD:
|
|
CLEAR_SET_FIELD(pkt_desc->srcLengthIVOffUseIVNext,
|
|
PKT_DSC_LOADHMACKEY, PKT_DSC_LOADHMACKEY_LOAD);
|
|
if (multi_frag_flag) {
|
|
CLEAR_SET_FIELD(next_pkt_desc->srcLengthIVOffUseIVNext,
|
|
PKT_DSC_LOADHMACKEY, PKT_DSC_LOADHMACKEY_LOAD);
|
|
|
|
}
|
|
break;
|
|
default:
|
|
if (vector & (XLR_SEC_VECTOR_HMAC | XLR_SEC_VECTOR_HMAC2 | XLR_SEC_VECTOR_GCM | XLR_SEC_VECTOR_F9)) {
|
|
XLR_SEC_CMD_DIAG("xlr_sec_setup_packet: ERR_LOADHMACKEY_MODE EXIT\n");
|
|
return XLR_SEC_ERR_LOADHMACKEY_MODE;
|
|
}
|
|
break;
|
|
}
|
|
|
|
switch (op->pkt_hash) {
|
|
case XLR_SEC_PADHASH_PADDED:
|
|
CLEAR_SET_FIELD(pkt_desc->srcLengthIVOffUseIVNext,
|
|
PKT_DSC_PADHASH, PKT_DSC_PADHASH_PADDED);
|
|
if (multi_frag_flag) {
|
|
CLEAR_SET_FIELD(next_pkt_desc->srcLengthIVOffUseIVNext,
|
|
PKT_DSC_PADHASH, PKT_DSC_PADHASH_PADDED);
|
|
}
|
|
break;
|
|
case XLR_SEC_PADHASH_PAD:
|
|
CLEAR_SET_FIELD(pkt_desc->srcLengthIVOffUseIVNext,
|
|
PKT_DSC_PADHASH, PKT_DSC_PADHASH_PAD);
|
|
if (multi_frag_flag) {
|
|
CLEAR_SET_FIELD(next_pkt_desc->srcLengthIVOffUseIVNext,
|
|
PKT_DSC_PADHASH, PKT_DSC_PADHASH_PAD);
|
|
}
|
|
break;
|
|
default:
|
|
if (vector & (XLR_SEC_VECTOR_MAC | XLR_SEC_VECTOR_HMAC | XLR_SEC_VECTOR_HMAC2)) {
|
|
XLR_SEC_CMD_DIAG("xlr_sec_setup_packet: ERR_PADHASH_MODE EXIT\n");
|
|
return XLR_SEC_ERR_PADHASH_MODE;
|
|
}
|
|
break;
|
|
}
|
|
|
|
switch (op->pkt_iv) {
|
|
case XLR_SEC_PKT_IV_OLD:
|
|
CLEAR_SET_FIELD(pkt_desc->srcLengthIVOffUseIVNext,
|
|
PKT_DSC_IV, PKT_DSC_IV_OLD);
|
|
if (multi_frag_flag) {
|
|
CLEAR_SET_FIELD(next_pkt_desc->srcLengthIVOffUseIVNext,
|
|
PKT_DSC_IV, PKT_DSC_IV_OLD);
|
|
|
|
}
|
|
break;
|
|
case XLR_SEC_PKT_IV_NEW:
|
|
CLEAR_SET_FIELD(pkt_desc->srcLengthIVOffUseIVNext,
|
|
PKT_DSC_IV, PKT_DSC_IV_NEW);
|
|
if (multi_frag_flag) {
|
|
CLEAR_SET_FIELD(next_pkt_desc->srcLengthIVOffUseIVNext,
|
|
PKT_DSC_IV, PKT_DSC_IV_NEW);
|
|
|
|
}
|
|
break;
|
|
default:
|
|
if (vector & XLR_SEC_VECTOR_CIPHER) {
|
|
XLR_SEC_CMD_DIAG("xlr_sec_setup_packet: ERR_PKT_IV_MODE EXIT\n");
|
|
return XLR_SEC_ERR_PKT_IV_MODE;
|
|
}
|
|
break;
|
|
}
|
|
|
|
XLR_SEC_CMD_DIAG("xlr_sec_setup_packet: src_buf=%llx phys_src_buf=%llx \n",
|
|
(unsigned long long)op->source_buf, (unsigned long long)addr);
|
|
|
|
XLR_SEC_CMD_DIAG("xlr_sec_setup_packet: seg_addr=%llx offset=%lld\n",
|
|
(unsigned long long)seg_addr, (unsigned long long)byte_offset);
|
|
|
|
XLR_SEC_CMD_DIAG("xlr_sec_setup_packet: global src offset: %d, iv_offset=%d\n",
|
|
cipher_offset_dwords, op->iv_offset);
|
|
|
|
XLR_SEC_CMD_DIAG("xlr_sec_setup_packet: src_buf_sz=%d PKT_LEN=%d\n",
|
|
op->source_buf_size, len_dwords);
|
|
|
|
/*
|
|
* same operation with the destination. cipher offset affects this,
|
|
* as well
|
|
*/
|
|
if (multi_frag_flag) {
|
|
next_seg_addr = (uint64_t) vtophys((void *)(unsigned long)(desc->next_dest_buf));
|
|
next_seg_addr = (next_seg_addr & ~(SMP_CACHE_BYTES - 1));
|
|
}
|
|
addr = (uint64_t) vtophys((void *)(unsigned long)op->dest_buf);
|
|
seg_addr = (addr & ~(SMP_CACHE_BYTES - 1));
|
|
byte_offset = addr - seg_addr;
|
|
global_offset = byte_offset & 0x7;
|
|
|
|
XLR_SEC_CMD_DIAG("xlr_sec_setup_packet: dest_buf=%llx phys_dest_buf=%llx \n",
|
|
(unsigned long long)op->dest_buf, (unsigned long long)addr);
|
|
|
|
XLR_SEC_CMD_DIAG("xlr_sec_setup_packet: seg_addr=%llx offset=%lld\n",
|
|
(unsigned long long)seg_addr, (unsigned long long)byte_offset);
|
|
|
|
/*
|
|
* Dest Address = (Cipher Dest Address) + (Cipher Offset) + (Global
|
|
* Dest Data Offset)
|
|
*
|
|
* Cipher Dest Address - Cache-line (0xffffffffe0) Cipher Offset -
|
|
* Which (64-bit) Word in Cacheline (0-3) Global Dest Data Offset -
|
|
* Number of Bytes in (64-bit) Word before data
|
|
*
|
|
* It must be set for Digest-only Ops, since the Digest engine will
|
|
* write data to this address.
|
|
*/
|
|
cipher_offset_dwords = (op->cipher_offset + byte_offset) >> 3;
|
|
|
|
|
|
pkt_desc->dstDataSettings =
|
|
/* SYM_OP, HASHSRC */
|
|
FIELD_VALUE(PKT_DSC_CPHROFF, cipher_offset_dwords) |
|
|
FIELD_VALUE(PKT_DSC_HASHOFF, (op->digest_offset + byte_offset) >> 3) |
|
|
FIELD_VALUE(PKT_DSC_CPHR_DST_ADDR, seg_addr) |
|
|
FIELD_VALUE(PKT_DSC_CPHR_DST_DWOFFSET, 0) |
|
|
FIELD_VALUE(PKT_DSC_CPHR_DST_OFFSET, global_offset);
|
|
|
|
if (multi_frag_flag) {
|
|
next_pkt_desc->dstDataSettings =
|
|
/* SYM_OP, HASHSRC */
|
|
FIELD_VALUE(PKT_DSC_CPHROFF, cipher_offset_dwords) |
|
|
FIELD_VALUE(PKT_DSC_HASHOFF, (op->digest_offset + byte_offset) >> 3) |
|
|
FIELD_VALUE(PKT_DSC_CPHR_DST_ADDR, next_seg_addr) |
|
|
FIELD_VALUE(PKT_DSC_CPHR_DST_DWOFFSET, 0) |
|
|
FIELD_VALUE(PKT_DSC_CPHR_DST_OFFSET, global_offset);
|
|
|
|
}
|
|
if (op->cipher_type == XLR_SEC_CIPHER_TYPE_ARC4)
|
|
pkt_desc->dstDataSettings |= FIELD_VALUE(PKT_DSC_ARC4BYTECOUNT, last_u64_bytes);
|
|
|
|
if (op->cipher_type != XLR_SEC_CIPHER_TYPE_NONE) {
|
|
switch (op->cipher_op) {
|
|
case XLR_SEC_CIPHER_OP_ENCRYPT:
|
|
CLEAR_SET_FIELD(pkt_desc->dstDataSettings,
|
|
PKT_DSC_SYM_OP, PKT_DSC_SYM_OP_ENCRYPT);
|
|
if (multi_frag_flag) {
|
|
CLEAR_SET_FIELD(next_pkt_desc->dstDataSettings,
|
|
PKT_DSC_SYM_OP, PKT_DSC_SYM_OP_ENCRYPT);
|
|
|
|
}
|
|
break;
|
|
case XLR_SEC_CIPHER_OP_DECRYPT:
|
|
CLEAR_SET_FIELD(pkt_desc->dstDataSettings,
|
|
PKT_DSC_SYM_OP, PKT_DSC_SYM_OP_DECRYPT);
|
|
if (multi_frag_flag) {
|
|
CLEAR_SET_FIELD(next_pkt_desc->dstDataSettings,
|
|
PKT_DSC_SYM_OP, PKT_DSC_SYM_OP_DECRYPT);
|
|
|
|
}
|
|
break;
|
|
default:
|
|
XLR_SEC_CMD_DIAG("xlr_sec_setup_packet: ERR_CIPHER_OP EXIT\n");
|
|
return XLR_SEC_ERR_CIPHER_OP;
|
|
}
|
|
}
|
|
if (flags & XLR_SEC_SETUP_OP_HMAC) {
|
|
switch (op->digest_src) {
|
|
case XLR_SEC_DIGEST_SRC_DMA:
|
|
CLEAR_SET_FIELD(pkt_desc->dstDataSettings,
|
|
PKT_DSC_HASHSRC, PKT_DSC_HASHSRC_DMA);
|
|
if (multi_frag_flag) {
|
|
CLEAR_SET_FIELD(next_pkt_desc->dstDataSettings,
|
|
PKT_DSC_HASHSRC, PKT_DSC_HASHSRC_DMA);
|
|
|
|
}
|
|
break;
|
|
case XLR_SEC_DIGEST_SRC_CPHR:
|
|
CLEAR_SET_FIELD(pkt_desc->dstDataSettings,
|
|
PKT_DSC_HASHSRC, PKT_DSC_HASHSRC_CIPHER);
|
|
if (multi_frag_flag) {
|
|
CLEAR_SET_FIELD(next_pkt_desc->dstDataSettings,
|
|
PKT_DSC_HASHSRC, PKT_DSC_HASHSRC_CIPHER);
|
|
}
|
|
break;
|
|
default:
|
|
XLR_SEC_CMD_DIAG("xlr_sec_setup_packet: ERR_DIGEST_SRC EXIT\n");
|
|
return XLR_SEC_ERR_DIGEST_SRC;
|
|
}
|
|
}
|
|
if (op->cksum_type != XLR_SEC_CKSUM_TYPE_NOP) {
|
|
switch (op->cksum_src) {
|
|
case XLR_SEC_CKSUM_SRC_DMA:
|
|
CLEAR_SET_FIELD(pkt_desc->dstDataSettings,
|
|
PKT_DSC_CKSUMSRC, PKT_DSC_CKSUMSRC_DMA);
|
|
if (multi_frag_flag) {
|
|
CLEAR_SET_FIELD(next_pkt_desc->dstDataSettings,
|
|
PKT_DSC_CKSUMSRC, PKT_DSC_CKSUMSRC_DMA);
|
|
}
|
|
break;
|
|
case XLR_SEC_CKSUM_SRC_CIPHER:
|
|
CLEAR_SET_FIELD(next_pkt_desc->dstDataSettings,
|
|
PKT_DSC_CKSUMSRC, PKT_DSC_CKSUMSRC_CIPHER);
|
|
if (multi_frag_flag) {
|
|
CLEAR_SET_FIELD(next_pkt_desc->dstDataSettings,
|
|
PKT_DSC_CKSUMSRC, PKT_DSC_CKSUMSRC_CIPHER);
|
|
}
|
|
break;
|
|
default:
|
|
XLR_SEC_CMD_DIAG("xlr_sec_setup_packet: ERR_CKSUM_SRC EXIT\n");
|
|
return XLR_SEC_ERR_CKSUM_SRC;
|
|
}
|
|
}
|
|
pkt_desc->ckSumDstNonceHiCFBMaskLLWMask =
|
|
FIELD_VALUE(PKT_DSC_HASH_BYTE_OFF, (op->digest_offset & 0x7)) |
|
|
FIELD_VALUE(PKT_DSC_PKTLEN_BYTES, 0) |
|
|
/* NONCE_HI, PKT_DSC_LASTWORD, CFB_MASK, CKSUM_DST_ADDR */
|
|
FIELD_VALUE(PKT_DSC_IV_OFF_HI, 0);
|
|
|
|
if (multi_frag_flag) {
|
|
next_pkt_desc->ckSumDstNonceHiCFBMaskLLWMask =
|
|
FIELD_VALUE(PKT_DSC_HASH_BYTE_OFF, (op->digest_offset & 0x7)) |
|
|
FIELD_VALUE(PKT_DSC_PKTLEN_BYTES, 0) |
|
|
/* NONCE_HI, PKT_DSC_LASTWORD, CFB_MASK, CKSUM_DST_ADDR */
|
|
FIELD_VALUE(PKT_DSC_IV_OFF_HI, 0);
|
|
|
|
}
|
|
switch (op->pkt_lastword) {
|
|
case XLR_SEC_LASTWORD_128:
|
|
CLEAR_SET_FIELD(pkt_desc->ckSumDstNonceHiCFBMaskLLWMask,
|
|
PKT_DSC_LASTWORD, PKT_DSC_LASTWORD_128);
|
|
if (multi_frag_flag) {
|
|
CLEAR_SET_FIELD(next_pkt_desc->ckSumDstNonceHiCFBMaskLLWMask,
|
|
PKT_DSC_LASTWORD, PKT_DSC_LASTWORD_128);
|
|
|
|
}
|
|
break;
|
|
case XLR_SEC_LASTWORD_96MASK:
|
|
CLEAR_SET_FIELD(pkt_desc->ckSumDstNonceHiCFBMaskLLWMask,
|
|
PKT_DSC_LASTWORD, PKT_DSC_LASTWORD_96MASK);
|
|
if (multi_frag_flag) {
|
|
CLEAR_SET_FIELD(next_pkt_desc->ckSumDstNonceHiCFBMaskLLWMask,
|
|
PKT_DSC_LASTWORD, PKT_DSC_LASTWORD_96MASK);
|
|
}
|
|
break;
|
|
case XLR_SEC_LASTWORD_64MASK:
|
|
CLEAR_SET_FIELD(pkt_desc->ckSumDstNonceHiCFBMaskLLWMask,
|
|
PKT_DSC_LASTWORD, PKT_DSC_LASTWORD_64MASK);
|
|
if (multi_frag_flag) {
|
|
CLEAR_SET_FIELD(next_pkt_desc->ckSumDstNonceHiCFBMaskLLWMask,
|
|
PKT_DSC_LASTWORD, PKT_DSC_LASTWORD_64MASK);
|
|
}
|
|
break;
|
|
case XLR_SEC_LASTWORD_32MASK:
|
|
CLEAR_SET_FIELD(pkt_desc->ckSumDstNonceHiCFBMaskLLWMask,
|
|
PKT_DSC_LASTWORD, PKT_DSC_LASTWORD_32MASK);
|
|
if (multi_frag_flag) {
|
|
CLEAR_SET_FIELD(next_pkt_desc->ckSumDstNonceHiCFBMaskLLWMask,
|
|
PKT_DSC_LASTWORD, PKT_DSC_LASTWORD_32MASK);
|
|
}
|
|
break;
|
|
default:
|
|
XLR_SEC_CMD_DIAG("xlr_sec_setup_packet: ERR_LASTWORD_MODE EXIT\n");
|
|
return XLR_SEC_ERR_LASTWORD_MODE;
|
|
}
|
|
CLEAR_SET_FIELD(pkt_desc->ckSumDstNonceHiCFBMaskLLWMask,
|
|
PKT_DSC_CFB_MASK, op->cfb_mask);
|
|
CLEAR_SET_FIELD(pkt_desc->ckSumDstNonceHiCFBMaskLLWMask,
|
|
PKT_DSC_NONCE_HI, htonl(op->nonce) >> 24);
|
|
CLEAR_SET_FIELD(pkt_desc->authDstNonceLow,
|
|
PKT_DSC_NONCE_LOW, htonl(op->nonce) & 0xffffff);
|
|
|
|
if (multi_frag_flag) {
|
|
CLEAR_SET_FIELD(next_pkt_desc->ckSumDstNonceHiCFBMaskLLWMask,
|
|
PKT_DSC_CFB_MASK, op->cfb_mask);
|
|
CLEAR_SET_FIELD(next_pkt_desc->ckSumDstNonceHiCFBMaskLLWMask,
|
|
PKT_DSC_NONCE_HI, htonl(op->nonce) >> 24);
|
|
CLEAR_SET_FIELD(next_pkt_desc->authDstNonceLow,
|
|
PKT_DSC_NONCE_LOW, htonl(op->nonce) & 0xffffff);
|
|
|
|
|
|
}
|
|
/* Auth Dest Address must be Cacheline aligned on input */
|
|
if (vector & (XLR_SEC_VECTOR_MAC | XLR_SEC_VECTOR_HMAC | XLR_SEC_VECTOR_HMAC2 | XLR_SEC_VECTOR_GCM | XLR_SEC_VECTOR_F9)) {
|
|
pkt_desc->authDstNonceLow |=
|
|
/* NONCE_LOW */
|
|
FIELD_VALUE(PKT_DSC_AUTH_DST_ADDR,
|
|
(uint64_t) vtophys((void *)(unsigned long)op->auth_dest)) |
|
|
FIELD_VALUE(PKT_DSC_CIPH_OFF_HI, 0);
|
|
|
|
|
|
if (multi_frag_flag) {
|
|
next_pkt_desc->authDstNonceLow |=
|
|
/* NONCE_LOW */
|
|
FIELD_VALUE(PKT_DSC_AUTH_DST_ADDR,
|
|
(uint64_t) vtophys((void *)(unsigned long)desc->next_auth_dest)) |
|
|
FIELD_VALUE(PKT_DSC_CIPH_OFF_HI, 0);
|
|
|
|
|
|
}
|
|
}
|
|
/* CkSum Dest Address must be Cacheline aligned on input */
|
|
if (op->cksum_type == XLR_SEC_CKSUM_TYPE_IP) {
|
|
CLEAR_SET_FIELD(pkt_desc->ckSumDstNonceHiCFBMaskLLWMask,
|
|
PKT_DSC_CKSUM_DST_ADDR,
|
|
(uint64_t) vtophys((void *)(unsigned long)op->cksum_dest));
|
|
|
|
if (multi_frag_flag) {
|
|
CLEAR_SET_FIELD(next_pkt_desc->ckSumDstNonceHiCFBMaskLLWMask,
|
|
PKT_DSC_CKSUM_DST_ADDR,
|
|
(uint64_t) vtophys((void *)(unsigned long)desc->next_cksum_dest));
|
|
|
|
}
|
|
}
|
|
/*
|
|
* XLR_SEC_CMD_DIAG (" xlr_sec_setup_packet(): pkt_desc=%llx
|
|
* phys_pkt_desc=%llx \n", (unsigned long long)pkt_desc, (unsigned
|
|
* long long)virt_to_phys(pkt_desc)); (unsigned long long)pkt_desc,
|
|
* (unsigned long long)vtophys(pkt_desc));
|
|
*/
|
|
XLR_SEC_CMD_DIAG(" xlr_sec_setup_packet(): pkt_desc=%p phys_pkt_desc=%llx \n",
|
|
pkt_desc, (unsigned long long)vtophys(pkt_desc));
|
|
|
|
|
|
|
|
CLEAR_SET_FIELD(*data, MSG_CMD_DATA_ADDR, ((uint64_t) vtophys(pkt_desc)));
|
|
CLEAR_SET_FIELD(*data, MSG_CMD_DATA_CTL, SEC_EOP);
|
|
CLEAR_SET_FIELD(*data, MSG_CMD_DATA_LEN, MSG_CMD_DATA_LEN_LOAD);
|
|
|
|
|
|
XLR_SEC_CMD_DIAG("xlr_sec_setup_packet: DONE\n");
|
|
|
|
#ifdef RMI_SEC_DEBUG
|
|
|
|
{
|
|
printf("data desc\n");
|
|
printf("srcLengthIVOffUseIVNext = 0x%llx\n", pkt_desc->srcLengthIVOffUseIVNext);
|
|
printf("dstDataSettings = 0x%llx\n", pkt_desc->dstDataSettings);
|
|
printf("authDstNonceLow = 0x%llx\n", pkt_desc->authDstNonceLow);
|
|
printf("ckSumDstNonceHiCFBMaskLLWMask = 0x%llx\n", pkt_desc->ckSumDstNonceHiCFBMaskLLWMask);
|
|
}
|
|
|
|
if (multi_frag_flag) {
|
|
|
|
printf("next data desc\n");
|
|
printf("srcLengthIVOffUseIVNext = 0x%llx\n", next_pkt_desc->srcLengthIVOffUseIVNext);
|
|
printf("dstDataSettings = 0x%llx\n", next_pkt_desc->dstDataSettings);
|
|
printf("authDstNonceLow = 0x%llx\n", next_pkt_desc->authDstNonceLow);
|
|
printf("ckSumDstNonceHiCFBMaskLLWMask = 0x%llx\n", next_pkt_desc->ckSumDstNonceHiCFBMaskLLWMask);
|
|
}
|
|
#endif
|
|
|
|
#ifdef SYMBOL
|
|
if (op->cipher_type == XLR_SEC_CIPHER_TYPE_ARC4) {
|
|
op->source_buf -= 0;
|
|
op->source_buf_size += 0;
|
|
op->dest_buf -= 0;
|
|
}
|
|
#endif
|
|
return XLR_SEC_ERR_NONE;
|
|
}
|
|
|
|
|
|
static int
|
|
identify_symkey_ctl_error(uint32_t code, xlr_sec_error_t err)
|
|
{
|
|
int ret_val = EINVAL;
|
|
|
|
switch (code) {
|
|
case CTL_ERR_NONE:
|
|
XLR_SEC_CMD_DIAG("XLR_SEC_SEC: CTL Error: No Error\n");
|
|
ret_val = 0;
|
|
break;
|
|
case CTL_ERR_CIPHER_OP:
|
|
XLR_SEC_CMD_DIAG("XLR_SEC_SEC: CTL Error(CTL_ERR_CIPHER_OP) - Unknown Cipher Op \n");
|
|
break;
|
|
case CTL_ERR_MODE:
|
|
XLR_SEC_CMD_DIAG("XLR_SEC_SEC: CTL Error(CTL_ERR_MODE) - "
|
|
"Unknown or Not Allowed Mode \n");
|
|
break;
|
|
case CTL_ERR_CHKSUM_SRC:
|
|
XLR_SEC_CMD_DIAG("XLR_SEC_SEC: CTL Error(CTL_ERR_CHKSUM_SRC) - Unknown CkSum Src\n");
|
|
break;
|
|
case CTL_ERR_CFB_MASK:
|
|
XLR_SEC_CMD_DIAG("XLR_SEC_SEC: CTL Error(CTL_ERR_CFB_MASK) - Forbidden CFB Mask \n");
|
|
break;
|
|
case CTL_ERR_OP:
|
|
XLR_SEC_CMD_DIAG("XLR_SEC_SEC: CTL Error(CTL_ERR_OP) - Unknown Ctrl Op \n");
|
|
break;
|
|
case CTL_ERR_DATA_READ:
|
|
XLR_SEC_CMD_DIAG("XLR_SEC_SEC: CTL Error(CTL_ERR_DATA_READ) - Data Read Error\n");
|
|
break;
|
|
case CTL_ERR_DESC_CTRL:
|
|
XLR_SEC_CMD_DIAG("XLR_SEC_SEC: CTL Error(CTL_ERR_DESC_CTRL) - "
|
|
"Descriptor Ctrl Field Error \n");
|
|
break;
|
|
case CTL_ERR_UNDEF1:
|
|
case CTL_ERR_UNDEF2:
|
|
default:
|
|
XLR_SEC_CMD_DIAG("XLR_SEC_SEC: CTL Error: UNKNOWN CODE=%d \n", code);
|
|
break;
|
|
}
|
|
return ret_val;
|
|
}
|
|
|
|
static
|
|
int
|
|
identify_symkey_data_error(uint32_t code, xlr_sec_error_t err)
|
|
{
|
|
int ret_val = -EINVAL;
|
|
|
|
switch (code) {
|
|
case DATA_ERR_NONE:
|
|
XLR_SEC_CMD_DIAG("XLR_SEC_SEC: DATA Error No Error\n");
|
|
ret_val = 0;
|
|
break;
|
|
case DATA_ERR_LEN_CIPHER:
|
|
XLR_SEC_CMD_DIAG("XLR_SEC_SEC: DATA Error() - Not Enough Data To Cipher\n");
|
|
break;
|
|
case DATA_ERR_IV_ADDR:
|
|
XLR_SEC_CMD_DIAG("XLR_SEC_SEC: DATA Error() - Illegal IV Loacation\n");
|
|
break;
|
|
case DATA_ERR_WD_LEN_AES:
|
|
XLR_SEC_CMD_DIAG("XLR_SEC_SEC: DATA Error() - Illegal Nb Words To AES\n");
|
|
break;
|
|
case DATA_ERR_BYTE_COUNT:
|
|
XLR_SEC_CMD_DIAG("XLR_SEC_SEC: DATA Error() - Illegal Pad And ByteCount Spec\n");
|
|
break;
|
|
case DATA_ERR_LEN_CKSUM:
|
|
XLR_SEC_CMD_DIAG("XLR_SEC_SEC: DATA Error() - Not Enough Data To CkSum\n");
|
|
break;
|
|
case DATA_ERR_OP:
|
|
XLR_SEC_CMD_DIAG("XLR_SEC_SEC: DATA Error() - Unknown Data Op \n");
|
|
break;
|
|
case DATA_ERR_READ:
|
|
XLR_SEC_CMD_DIAG("XLR_SEC_SEC: DATA Error() - Data Read Error \n");
|
|
break;
|
|
case DATA_ERR_WRITE:
|
|
XLR_SEC_CMD_DIAG("XLR_SEC_SEC: DATA Error() - Data Write Error \n");
|
|
break;
|
|
case DATA_ERR_UNDEF1:
|
|
default:
|
|
XLR_SEC_CMD_DIAG("XLR_SEC_SEC: DATA Error - UNKNOWN CODE=%d \n", code);
|
|
break;
|
|
}
|
|
return ret_val;
|
|
}
|
|
|
|
|
|
static int
|
|
xlr_sec_submit_message(symkey_desc_pt desc, uint32_t cfg_vector)
|
|
{
|
|
xlr_sec_error_t err;
|
|
uint32_t ctl_error, data_error;
|
|
int ret_val = 0;
|
|
|
|
XLR_SEC_CMD_DIAG("xlr_sec_submit_message: ENTER\n");
|
|
|
|
err = XLR_SEC_ERR_NONE;
|
|
|
|
XLR_SEC_CMD_DIAG_SYM_DESC(desc, cfg_vector);
|
|
|
|
do {
|
|
/* For now, send message and wait for response */
|
|
err = xlr_sec_submit_op(desc);
|
|
|
|
XLR_SEC_CMD_DIAG("xlr_sec_submit_message: err = %d \n", (uint32_t) err);
|
|
|
|
if (err != XLR_SEC_ERR_NONE) {
|
|
ret_val = (EINVAL);
|
|
break;
|
|
}
|
|
ctl_error = desc->ctl_result;
|
|
data_error = desc->data_result;
|
|
|
|
XLR_SEC_CMD_DIAG("xlr_sec_submit_message: ctl_error = %x data_error = %x\n",
|
|
ctl_error, data_error);
|
|
|
|
if ((ret_val = identify_symkey_ctl_error(ctl_error, err)) == 0)
|
|
ret_val = identify_symkey_data_error(data_error, err);
|
|
|
|
XLR_SEC_CMD_DIAG("xlr_sec_submit_message: identify error = %d \n", ret_val);
|
|
|
|
} while (0);
|
|
|
|
XLR_SEC_CMD_DIAG("xlr_sec_submit_message: DONE\n");
|
|
return (ret_val);
|
|
}
|
|
|
|
|
|
static
|
|
xlr_sec_error_t
|
|
xlr_sec_setup_cipher(xlr_sec_io_pt op,
|
|
ControlDescriptor_pt ctl_desc,
|
|
uint32_t * vector)
|
|
{
|
|
uint32_t aes_flag = 0;
|
|
uint32_t cipher_vector = 0;
|
|
|
|
XLR_SEC_CMD_DIAG("xlr_sec_setup_cipher: ENTER vector = %04x\n", *vector);
|
|
|
|
switch (op->cipher_type) {
|
|
case XLR_SEC_CIPHER_TYPE_NONE:
|
|
SET_FIELD(ctl_desc->instruction, CTL_DSC_CPHR, CTL_DSC_CPHR_BYPASS);
|
|
XLR_SEC_CMD_DIAG("xlr_sec_setup_cipher: CIPHER_TYPE_NONE EXIT\n");
|
|
return XLR_SEC_ERR_NONE;
|
|
case XLR_SEC_CIPHER_TYPE_DES:
|
|
cipher_vector |= XLR_SEC_VECTOR_CIPHER_DES;
|
|
SET_FIELD(ctl_desc->instruction, CTL_DSC_CPHR, CTL_DSC_CPHR_DES);
|
|
break;
|
|
case XLR_SEC_CIPHER_TYPE_3DES:
|
|
cipher_vector |= XLR_SEC_VECTOR_CIPHER_3DES;
|
|
SET_FIELD(ctl_desc->instruction, CTL_DSC_CPHR, CTL_DSC_CPHR_3DES);
|
|
break;
|
|
case XLR_SEC_CIPHER_TYPE_AES128:
|
|
aes_flag = 1;
|
|
cipher_vector |= XLR_SEC_VECTOR_CIPHER_AES128;
|
|
SET_FIELD(ctl_desc->instruction, CTL_DSC_CPHR, CTL_DSC_CPHR_AES128);
|
|
break;
|
|
case XLR_SEC_CIPHER_TYPE_AES192:
|
|
aes_flag = 1;
|
|
cipher_vector |= XLR_SEC_VECTOR_CIPHER_AES192;
|
|
SET_FIELD(ctl_desc->instruction, CTL_DSC_CPHR, CTL_DSC_CPHR_AES192);
|
|
break;
|
|
case XLR_SEC_CIPHER_TYPE_AES256:
|
|
aes_flag = 1;
|
|
cipher_vector |= XLR_SEC_VECTOR_CIPHER_AES256;
|
|
SET_FIELD(ctl_desc->instruction, CTL_DSC_CPHR, CTL_DSC_CPHR_AES256);
|
|
break;
|
|
case XLR_SEC_CIPHER_TYPE_ARC4:
|
|
cipher_vector |= XLR_SEC_VECTOR_CIPHER_ARC4;
|
|
SET_FIELD(ctl_desc->instruction, CTL_DSC_CPHR, CTL_DSC_CPHR_ARC4);
|
|
SET_FIELD(ctl_desc->instruction, CTL_DSC_ARC4_KEYLEN,
|
|
op->rc4_key_len);
|
|
SET_FIELD(ctl_desc->instruction, CTL_DSC_ARC4_LOADSTATE,
|
|
op->rc4_loadstate);
|
|
SET_FIELD(ctl_desc->instruction, CTL_DSC_ARC4_SAVESTATE,
|
|
op->rc4_savestate);
|
|
if (op->rc4_loadstate || op->rc4_savestate)
|
|
cipher_vector |= XLR_SEC_VECTOR_STATE;
|
|
break;
|
|
case XLR_SEC_CIPHER_TYPE_KASUMI_F8:
|
|
aes_flag = 1;
|
|
cipher_vector |= XLR_SEC_VECTOR_CIPHER_KASUMI_F8;
|
|
SET_FIELD(ctl_desc->instruction, CTL_DSC_CPHR, CTL_DSC_CPHR_KASUMI_F8);
|
|
break;
|
|
default:
|
|
XLR_SEC_CMD_DIAG("xlr_sec_setup_cipher: ERR_CIPHER_TYPE EXIT\n");
|
|
return XLR_SEC_ERR_CIPHER_TYPE;
|
|
}
|
|
|
|
switch (op->cipher_mode) {
|
|
case XLR_SEC_CIPHER_MODE_ECB:
|
|
if (aes_flag == 1)
|
|
cipher_vector |= XLR_SEC_VECTOR_MODE_ECB_CBC_OFB;
|
|
else
|
|
cipher_vector |= XLR_SEC_VECTOR_MODE_ECB_CBC;
|
|
SET_FIELD(ctl_desc->instruction, CTL_DSC_MODE, CTL_DSC_MODE_ECB);
|
|
break;
|
|
case XLR_SEC_CIPHER_MODE_CBC:
|
|
if (aes_flag == 1)
|
|
cipher_vector |= XLR_SEC_VECTOR_MODE_ECB_CBC_OFB;
|
|
else
|
|
cipher_vector |= XLR_SEC_VECTOR_MODE_ECB_CBC;
|
|
SET_FIELD(ctl_desc->instruction, CTL_DSC_MODE, CTL_DSC_MODE_CBC);
|
|
break;
|
|
case XLR_SEC_CIPHER_MODE_OFB:
|
|
if (aes_flag == 0) {
|
|
XLR_SEC_CMD_DIAG("xlr_sec_setup_cipher: ERR_CIPHER_MODE EXIT\n");
|
|
return XLR_SEC_ERR_CIPHER_MODE;
|
|
}
|
|
cipher_vector |= XLR_SEC_VECTOR_MODE_ECB_CBC_OFB;
|
|
SET_FIELD(ctl_desc->instruction, CTL_DSC_MODE, CTL_DSC_MODE_OFB);
|
|
break;
|
|
case XLR_SEC_CIPHER_MODE_CTR:
|
|
if (aes_flag == 0) {
|
|
XLR_SEC_CMD_DIAG("xlr_sec_setup_cipher: ERR_CIPHER_MODE EXIT\n");
|
|
return XLR_SEC_ERR_CIPHER_MODE;
|
|
}
|
|
cipher_vector |= XLR_SEC_VECTOR_MODE_CTR_CFB;
|
|
SET_FIELD(ctl_desc->instruction, CTL_DSC_MODE, CTL_DSC_MODE_CTR);
|
|
break;
|
|
case XLR_SEC_CIPHER_MODE_CFB:
|
|
if (aes_flag == 0) {
|
|
XLR_SEC_CMD_DIAG("xlr_sec_setup_cipher: ERR_CIPHER_MODE EXIT\n");
|
|
return XLR_SEC_ERR_CIPHER_MODE;
|
|
}
|
|
cipher_vector |= XLR_SEC_VECTOR_MODE_CTR_CFB;
|
|
SET_FIELD(ctl_desc->instruction, CTL_DSC_MODE, CTL_DSC_MODE_CFB);
|
|
break;
|
|
case XLR_SEC_CIPHER_MODE_F8:
|
|
if (aes_flag == 0) {
|
|
XLR_SEC_CMD_DIAG("xlr_sec_setup_cipher: ERR_CIPHER_MODE EXIT\n");
|
|
return XLR_SEC_ERR_CIPHER_MODE;
|
|
}
|
|
cipher_vector |= XLR_SEC_VECTOR_MODE_F8;
|
|
SET_FIELD(ctl_desc->instruction, CTL_DSC_MODE, CTL_DSC_MODE_F8);
|
|
break;
|
|
default:
|
|
if (!(cipher_vector & (XLR_SEC_VECTOR_CIPHER_ARC4 | XLR_SEC_VECTOR_CIPHER_KASUMI_F8))) {
|
|
XLR_SEC_CMD_DIAG("xlr_sec_setup_cipher: ERR_CIPHER_MODE EXIT\n");
|
|
return XLR_SEC_ERR_CIPHER_MODE;
|
|
}
|
|
}
|
|
|
|
switch (op->cipher_init) {
|
|
case XLR_SEC_CIPHER_INIT_OK:
|
|
SET_FIELD(ctl_desc->instruction,
|
|
CTL_DSC_ICPHR, CTL_DSC_ICPHR_OKY);
|
|
break;
|
|
|
|
case XLR_SEC_CIPHER_INIT_NK:
|
|
SET_FIELD(ctl_desc->instruction,
|
|
CTL_DSC_ICPHR, CTL_DSC_ICPHR_NKY);
|
|
break;
|
|
default:
|
|
XLR_SEC_CMD_DIAG("xlr_sec_setup_cipher: ERR_CIPHER_INIT EXIT\n");
|
|
return XLR_SEC_ERR_CIPHER_INIT;
|
|
}
|
|
|
|
*vector |= cipher_vector;
|
|
|
|
XLR_SEC_CMD_DIAG("xlr_sec_setup_cipher: EXIT vector = %04x\n", *vector);
|
|
|
|
return XLR_SEC_ERR_NONE;
|
|
}
|
|
|
|
|
|
static
|
|
xlr_sec_error_t
|
|
xlr_sec_setup_digest(xlr_sec_io_pt op,
|
|
ControlDescriptor_pt ctl_desc,
|
|
uint32_t * vector)
|
|
{
|
|
uint32_t hash_flag = 0;
|
|
uint32_t hmac_flag = 0;
|
|
uint32_t digest_vector = 0;
|
|
|
|
XLR_SEC_CMD_DIAG("xlr_sec_setup_digest: ENTER vector = %04x\n", *vector);
|
|
|
|
switch (op->digest_type) {
|
|
case XLR_SEC_DIGEST_TYPE_MD5:
|
|
digest_vector |= XLR_SEC_VECTOR_MAC;
|
|
SET_FIELD(ctl_desc->instruction, CTL_DSC_HASH, CTL_DSC_HASH_MD5);
|
|
break;
|
|
case XLR_SEC_DIGEST_TYPE_SHA1:
|
|
digest_vector |= XLR_SEC_VECTOR_MAC;
|
|
SET_FIELD(ctl_desc->instruction, CTL_DSC_HASH, CTL_DSC_HASH_SHA1);
|
|
break;
|
|
case XLR_SEC_DIGEST_TYPE_SHA256:
|
|
digest_vector |= XLR_SEC_VECTOR_MAC;
|
|
SET_FIELD(ctl_desc->instruction, CTL_DSC_HASH, CTL_DSC_HASH_SHA256);
|
|
break;
|
|
case XLR_SEC_DIGEST_TYPE_SHA384:
|
|
digest_vector |= XLR_SEC_VECTOR_MAC;
|
|
SET_FIELD(ctl_desc->instruction, CTL_DSC_HASHHI, CTL_DSC_HASH_SHA384 >> 2);
|
|
SET_FIELD(ctl_desc->instruction, CTL_DSC_HASH, CTL_DSC_HASH_SHA384);
|
|
break;
|
|
case XLR_SEC_DIGEST_TYPE_SHA512:
|
|
digest_vector |= XLR_SEC_VECTOR_MAC;
|
|
SET_FIELD(ctl_desc->instruction, CTL_DSC_HASHHI, CTL_DSC_HASH_SHA512 >> 2);
|
|
SET_FIELD(ctl_desc->instruction, CTL_DSC_HASH, CTL_DSC_HASH_SHA512);
|
|
break;
|
|
case XLR_SEC_DIGEST_TYPE_GCM:
|
|
hash_flag = 1;
|
|
digest_vector |= XLR_SEC_VECTOR_GCM;
|
|
SET_FIELD(ctl_desc->instruction, CTL_DSC_HASHHI, CTL_DSC_HASH_GCM >> 2);
|
|
SET_FIELD(ctl_desc->instruction, CTL_DSC_HASH, CTL_DSC_HASH_GCM);
|
|
break;
|
|
case XLR_SEC_DIGEST_TYPE_KASUMI_F9:
|
|
hash_flag = 1;
|
|
digest_vector |= XLR_SEC_VECTOR_F9;
|
|
SET_FIELD(ctl_desc->instruction, CTL_DSC_HASHHI, CTL_DSC_HASH_KASUMI_F9 >> 2);
|
|
SET_FIELD(ctl_desc->instruction, CTL_DSC_HASH, CTL_DSC_HASH_KASUMI_F9);
|
|
break;
|
|
case XLR_SEC_DIGEST_TYPE_HMAC_MD5:
|
|
hmac_flag = 1;
|
|
digest_vector |= XLR_SEC_VECTOR_HMAC;
|
|
SET_FIELD(ctl_desc->instruction, CTL_DSC_HASH, CTL_DSC_HASH_MD5);
|
|
break;
|
|
case XLR_SEC_DIGEST_TYPE_HMAC_SHA1:
|
|
hmac_flag = 1;
|
|
digest_vector |= XLR_SEC_VECTOR_HMAC;
|
|
SET_FIELD(ctl_desc->instruction, CTL_DSC_HASH, CTL_DSC_HASH_SHA1);
|
|
break;
|
|
case XLR_SEC_DIGEST_TYPE_HMAC_SHA256:
|
|
hmac_flag = 1;
|
|
digest_vector |= XLR_SEC_VECTOR_HMAC;
|
|
SET_FIELD(ctl_desc->instruction, CTL_DSC_HASH, CTL_DSC_HASH_SHA256);
|
|
break;
|
|
case XLR_SEC_DIGEST_TYPE_HMAC_SHA384:
|
|
hmac_flag = 1;
|
|
digest_vector |= XLR_SEC_VECTOR_HMAC2;
|
|
SET_FIELD(ctl_desc->instruction, CTL_DSC_HASHHI, CTL_DSC_HASH_SHA384 >> 2);
|
|
SET_FIELD(ctl_desc->instruction, CTL_DSC_HASH, CTL_DSC_HASH_SHA384);
|
|
break;
|
|
case XLR_SEC_DIGEST_TYPE_HMAC_SHA512:
|
|
hmac_flag = 1;
|
|
digest_vector |= XLR_SEC_VECTOR_HMAC2;
|
|
SET_FIELD(ctl_desc->instruction, CTL_DSC_HASHHI, CTL_DSC_HASH_SHA512 >> 2);
|
|
SET_FIELD(ctl_desc->instruction, CTL_DSC_HASH, CTL_DSC_HASH_SHA512);
|
|
break;
|
|
default:
|
|
return XLR_SEC_ERR_DIGEST_TYPE;
|
|
}
|
|
|
|
if (hmac_flag == 1) {
|
|
SET_FIELD(ctl_desc->instruction, CTL_DSC_HMAC, CTL_DSC_HMAC_ON);
|
|
|
|
}
|
|
if (hmac_flag || hash_flag) {
|
|
switch (op->digest_init) {
|
|
case XLR_SEC_DIGEST_INIT_OLDKEY:
|
|
SET_FIELD(ctl_desc->instruction, CTL_DSC_IHASH, CTL_DSC_IHASH_OLD);
|
|
break;
|
|
case XLR_SEC_DIGEST_INIT_NEWKEY:
|
|
SET_FIELD(ctl_desc->instruction, CTL_DSC_IHASH, CTL_DSC_IHASH_NEW);
|
|
break;
|
|
default:
|
|
return XLR_SEC_ERR_DIGEST_INIT;
|
|
}
|
|
} /* hmac_flag */
|
|
*vector |= digest_vector;
|
|
|
|
XLR_SEC_CMD_DIAG("xlr_sec_setup_digest: EXIT vector = %04x\n", *vector);
|
|
|
|
return XLR_SEC_ERR_NONE;
|
|
}
|
|
|
|
static
|
|
xlr_sec_error_t
|
|
xlr_sec_setup_cksum(xlr_sec_io_pt op,
|
|
ControlDescriptor_pt ctl_desc)
|
|
{
|
|
switch (op->cksum_type) {
|
|
case XLR_SEC_CKSUM_TYPE_NOP:
|
|
SET_FIELD(ctl_desc->instruction, CTL_DSC_CKSUM, CTL_DSC_CKSUM_NOP);
|
|
return XLR_SEC_ERR_NONE;
|
|
case XLR_SEC_CKSUM_TYPE_IP:
|
|
SET_FIELD(ctl_desc->instruction, CTL_DSC_CKSUM, CTL_DSC_CKSUM_IP);
|
|
break;
|
|
default:
|
|
return XLR_SEC_ERR_CKSUM_TYPE;
|
|
}
|
|
|
|
return XLR_SEC_ERR_NONE;
|
|
}
|
|
|
|
|
|
static
|
|
xlr_sec_error_t
|
|
xlr_sec_control_setup(xlr_sec_io_pt op,
|
|
unsigned int flags,
|
|
uint64_t * control,
|
|
ControlDescriptor_pt ctl_desc,
|
|
xlr_sec_drv_user_t * user,
|
|
uint32_t vector)
|
|
{
|
|
uint64_t *hmac_key = NULL;
|
|
uint64_t *cipher_key = NULL;
|
|
uint64_t *cipher_state = NULL;
|
|
uint32_t ctl_size = 0;
|
|
uint64_t ctl_addr = 0;
|
|
uint32_t cipher_keylen = 0;
|
|
uint32_t hmac_keylen = 0;
|
|
uint32_t ctl_len;
|
|
|
|
#ifdef SYM_DEBUG
|
|
XLR_SEC_CMD_DIAG(" ENTER vector = %04x\n", vector);
|
|
#endif
|
|
|
|
|
|
switch (vector) {
|
|
case XLR_SEC_VECTOR_MAC:
|
|
XLR_SEC_CMD_DIAG(" XLR_SEC_VECTOR_MAC \n");
|
|
ctl_size = sizeof(HMAC_t);
|
|
break;
|
|
case XLR_SEC_VECTOR_HMAC:
|
|
XLR_SEC_CMD_DIAG("XLR_SEC_VECTOR_HMAC \n");
|
|
hmac_key = &ctl_desc->cipherHashInfo.infoHMAC.hmacKey0;
|
|
hmac_keylen = sizeof(HMAC_t);
|
|
ctl_size = sizeof(HMAC_t);
|
|
break;
|
|
case XLR_SEC_VECTOR_CIPHER_ARC4:
|
|
XLR_SEC_CMD_DIAG("XLR_SEC_VECTOR_CIPHER_ARC4\n");
|
|
cipher_key = &ctl_desc->cipherHashInfo.infoARC4.cipherKey0;
|
|
cipher_keylen = op->rc4_key_len;
|
|
ctl_size = sizeof(ARC4_t);
|
|
break;
|
|
case XLR_SEC_VECTOR_CIPHER_ARC4__HMAC:
|
|
XLR_SEC_CMD_DIAG("XLR_SEC_VECTOR_CIPHER_ARC4__HMAC\n");
|
|
cipher_key = &ctl_desc->cipherHashInfo.infoARC4HMAC.cipherKey0;
|
|
hmac_key = &ctl_desc->cipherHashInfo.infoARC4HMAC.hmacKey0;
|
|
cipher_keylen = op->rc4_key_len;
|
|
hmac_keylen = sizeof(HMAC_t);
|
|
ctl_size = sizeof(ARC4HMAC_t);
|
|
break;
|
|
case XLR_SEC_VECTOR_CIPHER_ARC4__STATE:
|
|
XLR_SEC_CMD_DIAG("XLR_SEC_VECTOR_CIPHER_ARC4__STATE\n");
|
|
cipher_key = &ctl_desc->cipherHashInfo.infoARC4State.cipherKey0;
|
|
cipher_state =
|
|
&ctl_desc->cipherHashInfo.infoARC4State.Arc4SboxData0;
|
|
cipher_keylen = op->rc4_key_len;
|
|
ctl_size = sizeof(ARC4State_t);
|
|
break;
|
|
case XLR_SEC_VECTOR_CIPHER_ARC4__HMAC__STATE:
|
|
XLR_SEC_CMD_DIAG("XLR_SEC_VECTOR_CIPHER_ARC4__HMAC__STATE\n");
|
|
cipher_key = &ctl_desc->cipherHashInfo.infoARC4StateHMAC.cipherKey0;
|
|
cipher_state =
|
|
&ctl_desc->cipherHashInfo.infoARC4StateHMAC.Arc4SboxData0;
|
|
hmac_key = &ctl_desc->cipherHashInfo.infoARC4StateHMAC.hmacKey0;
|
|
cipher_keylen = op->rc4_key_len;
|
|
hmac_keylen = sizeof(HMAC_t);
|
|
ctl_size = sizeof(ARC4StateHMAC_t);
|
|
break;
|
|
case XLR_SEC_VECTOR_CIPHER_KASUMI_F8:
|
|
XLR_SEC_CMD_DIAG("XLR_SEC_VECTOR_CIPHER_KASUMI_F8\n");
|
|
cipher_key = &ctl_desc->cipherHashInfo.infoKASUMIF8.cipherKey0;
|
|
cipher_keylen = XLR_SEC_KASUMI_F8_KEY_LENGTH;
|
|
ctl_size = sizeof(KASUMIF8_t);
|
|
break;
|
|
case XLR_SEC_VECTOR_CIPHER_KASUMI_F8__HMAC:
|
|
XLR_SEC_CMD_DIAG("XLR_SEC_VECTOR_CIPHER_KASUMI_F8__HMAC\n");
|
|
cipher_key = &ctl_desc->cipherHashInfo.infoKASUMIF8HMAC.cipherKey0;
|
|
cipher_keylen = XLR_SEC_KASUMI_F8_KEY_LENGTH;
|
|
hmac_key = &ctl_desc->cipherHashInfo.infoKASUMIF8HMAC.hmacKey0;
|
|
hmac_keylen = sizeof(HMAC_t);
|
|
ctl_size = sizeof(KASUMIF8HMAC_t);
|
|
break;
|
|
case XLR_SEC_VECTOR_CIPHER_KASUMI_F8__HMAC2:
|
|
XLR_SEC_CMD_DIAG("XLR_SEC_VECTOR_CIPHER_KASUMI_F8__HMAC2\n");
|
|
cipher_key = &ctl_desc->cipherHashInfo.infoKASUMIF8HMAC2.cipherKey0;
|
|
cipher_keylen = XLR_SEC_KASUMI_F8_KEY_LENGTH;
|
|
hmac_key = &ctl_desc->cipherHashInfo.infoKASUMIF8HMAC2.hmacKey0;
|
|
hmac_keylen = sizeof(HMAC2_t);
|
|
ctl_size = sizeof(KASUMIF8HMAC2_t);
|
|
break;
|
|
case XLR_SEC_VECTOR_CIPHER_KASUMI_F8__GCM:
|
|
XLR_SEC_CMD_DIAG("XLR_SEC_VECTOR_CIPHER_KASUMI_F8__GCM\n");
|
|
cipher_key = &ctl_desc->cipherHashInfo.infoKASUMIF8GCM.cipherKey0;
|
|
cipher_keylen = XLR_SEC_KASUMI_F8_KEY_LENGTH;
|
|
hmac_key = &ctl_desc->cipherHashInfo.infoKASUMIF8GCM.GCMH0;
|
|
hmac_keylen = sizeof(GCM_t);
|
|
ctl_size = sizeof(KASUMIF8GCM_t);
|
|
break;
|
|
case XLR_SEC_VECTOR_CIPHER_KASUMI_F8__F9:
|
|
XLR_SEC_CMD_DIAG("XLR_SEC_VECTOR_CIPHER_KASUMI_F8__F9\n");
|
|
cipher_key = &ctl_desc->cipherHashInfo.infoKASUMIF8F9.cipherKey0;
|
|
cipher_keylen = XLR_SEC_KASUMI_F8_KEY_LENGTH;
|
|
hmac_key = &ctl_desc->cipherHashInfo.infoKASUMIF8F9.authKey0;
|
|
hmac_keylen = sizeof(F9_t);
|
|
ctl_size = sizeof(KASUMIF8F9_t);
|
|
break;
|
|
case XLR_SEC_VECTOR__CIPHER_DES__HMAC__MODE_ECB_CBC:
|
|
XLR_SEC_CMD_DIAG(" XLR_SEC_VECTOR__CIPHER_DES__HMAC__MODE_ECB_CBC \n");
|
|
cipher_key = &ctl_desc->cipherHashInfo.infoDESHMAC.cipherKey0;
|
|
hmac_key = &ctl_desc->cipherHashInfo.infoDESHMAC.hmacKey0;
|
|
hmac_keylen = sizeof(HMAC_t);
|
|
cipher_keylen = XLR_SEC_DES_KEY_LENGTH;
|
|
ctl_size = sizeof(DESHMAC_t);
|
|
break;
|
|
case XLR_SEC_VECTOR__CIPHER_DES__MODE_ECB_CBC:
|
|
XLR_SEC_CMD_DIAG("XLR_SEC_VECTOR__CIPHER_DES__MODE_ECB_CBC \n");
|
|
cipher_key = &ctl_desc->cipherHashInfo.infoDES.cipherKey0;
|
|
cipher_keylen = XLR_SEC_DES_KEY_LENGTH;
|
|
ctl_size = sizeof(DES_t);
|
|
break;
|
|
case XLR_SEC_VECTOR__CIPHER_3DES__HMAC__MODE_ECB_CBC:
|
|
XLR_SEC_CMD_DIAG("XLR_SEC_VECTOR__CIPHER_3DES__HMAC__MODE_ECB_CBC \n");
|
|
cipher_key = &ctl_desc->cipherHashInfo.info3DESHMAC.cipherKey0;
|
|
hmac_key = &ctl_desc->cipherHashInfo.info3DESHMAC.hmacKey0;
|
|
cipher_keylen = XLR_SEC_3DES_KEY_LENGTH;
|
|
hmac_keylen = sizeof(HMAC_t);
|
|
ctl_size = sizeof(DES3HMAC_t);
|
|
break;
|
|
case XLR_SEC_VECTOR__CIPHER_3DES__MODE_ECB_CBC:
|
|
XLR_SEC_CMD_DIAG("XLR_SEC_VECTOR__CIPHER_3DES__MODE_ECB_CBC \n");
|
|
cipher_key = &ctl_desc->cipherHashInfo.info3DES.cipherKey0;
|
|
cipher_keylen = XLR_SEC_3DES_KEY_LENGTH;
|
|
ctl_size = sizeof(DES3_t);
|
|
break;
|
|
case XLR_SEC_VECTOR__CIPHER_AES128__HMAC__MODE_CTR_CFB:
|
|
XLR_SEC_CMD_DIAG("XLR_SEC_VECTOR__CIPHER_AES128__HMAC__MODE_CTR_CFB \n");
|
|
cipher_key = &ctl_desc->cipherHashInfo.infoAES128HMAC.cipherKey0;
|
|
hmac_key = &ctl_desc->cipherHashInfo.infoAES128HMAC.hmacKey0;
|
|
cipher_keylen = XLR_SEC_AES128_KEY_LENGTH;
|
|
hmac_keylen = sizeof(HMAC_t);
|
|
ctl_size = sizeof(AES128HMAC_t);
|
|
break;
|
|
case XLR_SEC_VECTOR__CIPHER_AES128__MODE_CTR_CFB:
|
|
XLR_SEC_CMD_DIAG("XLR_SEC_VECTOR__CIPHER_AES128__MODE_CTR_CFB \n");
|
|
cipher_key = &ctl_desc->cipherHashInfo.infoAES128.cipherKey0;
|
|
cipher_keylen = XLR_SEC_AES128_KEY_LENGTH;
|
|
ctl_size = sizeof(AES128_t);
|
|
break;
|
|
case XLR_SEC_VECTOR__CIPHER_AES128__HMAC__MODE_ECB_CBC_OFB:
|
|
XLR_SEC_CMD_DIAG(" XLR_SEC_VECTOR__CIPHER_AES128__HMAC__MODE_ECB_CBC_OFB \n");
|
|
cipher_key = &ctl_desc->cipherHashInfo.infoAES128HMAC.cipherKey0;
|
|
hmac_key = &ctl_desc->cipherHashInfo.infoAES128HMAC.hmacKey0;
|
|
cipher_keylen = XLR_SEC_AES128_KEY_LENGTH;
|
|
hmac_keylen = sizeof(HMAC_t);
|
|
ctl_size = sizeof(AES128HMAC_t);
|
|
break;
|
|
case XLR_SEC_VECTOR__CIPHER_AES128__MODE_ECB_CBC_OFB:
|
|
XLR_SEC_CMD_DIAG("XLR_SEC_VECTOR__CIPHER_AES128__MODE_ECB_CBC_OFB \n");
|
|
cipher_key = &ctl_desc->cipherHashInfo.infoAES128.cipherKey0;
|
|
cipher_keylen = XLR_SEC_AES128_KEY_LENGTH;
|
|
ctl_size = sizeof(AES128_t);
|
|
break;
|
|
case XLR_SEC_VECTOR__CIPHER_AES128__HMAC__MODE_F8:
|
|
XLR_SEC_CMD_DIAG("XLR_SEC_VECTOR__CIPHER_AES128__HMAC__MODE_F8 \n");
|
|
cipher_key = &ctl_desc->cipherHashInfo.infoAES128F8HMAC.cipherKey0;
|
|
hmac_key = &ctl_desc->cipherHashInfo.infoAES128F8HMAC.hmacKey0;
|
|
cipher_keylen = XLR_SEC_AES128F8_KEY_LENGTH;
|
|
hmac_keylen = sizeof(HMAC_t);
|
|
ctl_size = sizeof(AES128F8HMAC_t);
|
|
break;
|
|
case XLR_SEC_VECTOR__CIPHER_AES128__MODE_F8:
|
|
XLR_SEC_CMD_DIAG("XLR_SEC_VECTOR__CIPHER_AES128__MODE_F8 \n");
|
|
cipher_key = &ctl_desc->cipherHashInfo.infoAES128F8.cipherKey0;
|
|
cipher_keylen = XLR_SEC_AES128F8_KEY_LENGTH;
|
|
ctl_size = sizeof(AES128F8_t);
|
|
break;
|
|
case XLR_SEC_VECTOR__CIPHER_AES192__HMAC__MODE_CTR_CFB:
|
|
XLR_SEC_CMD_DIAG("XLR_SEC_VECTOR__CIPHER_AES192__HMAC__MODE_CTR_CFB \n");
|
|
cipher_key = &ctl_desc->cipherHashInfo.infoAES192HMAC.cipherKey0;
|
|
hmac_key = &ctl_desc->cipherHashInfo.infoAES192HMAC.hmacKey0;
|
|
cipher_keylen = XLR_SEC_AES192_KEY_LENGTH;
|
|
hmac_keylen = sizeof(HMAC_t);
|
|
ctl_size = sizeof(AES192HMAC_t);
|
|
break;
|
|
case XLR_SEC_VECTOR__CIPHER_AES192__MODE_CTR_CFB:
|
|
XLR_SEC_CMD_DIAG("XLR_SEC_VECTOR__CIPHER_AES192__MODE_CTR_CFB \n");
|
|
cipher_key = &ctl_desc->cipherHashInfo.infoAES192.cipherKey0;
|
|
cipher_keylen = XLR_SEC_AES192_KEY_LENGTH;
|
|
ctl_size = sizeof(AES192_t);
|
|
break;
|
|
case XLR_SEC_VECTOR__CIPHER_AES192__HMAC__MODE_ECB_CBC_OFB:
|
|
XLR_SEC_CMD_DIAG("XLR_SEC_VECTOR__CIPHER_AES192__HMAC__MODE_ECB_CBC_OFB \n");
|
|
cipher_key = &ctl_desc->cipherHashInfo.infoAES192HMAC.cipherKey0;
|
|
hmac_key = &ctl_desc->cipherHashInfo.infoAES192HMAC.hmacKey0;
|
|
cipher_keylen = XLR_SEC_AES192_KEY_LENGTH;
|
|
hmac_keylen = sizeof(HMAC_t);
|
|
ctl_size = sizeof(AES192HMAC_t);
|
|
break;
|
|
case XLR_SEC_VECTOR__CIPHER_AES192__MODE_ECB_CBC_OFB:
|
|
XLR_SEC_CMD_DIAG("XLR_SEC_VECTOR__CIPHER_AES192__MODE_ECB_CBC_OFB \n");
|
|
cipher_key = &ctl_desc->cipherHashInfo.infoAES192.cipherKey0;
|
|
cipher_keylen = XLR_SEC_AES192_KEY_LENGTH;
|
|
ctl_size = sizeof(AES192_t);
|
|
break;
|
|
case XLR_SEC_VECTOR__CIPHER_AES192__HMAC__MODE_F8:
|
|
XLR_SEC_CMD_DIAG("XLR_SEC_VECTOR__CIPHER_AES192__HMAC__MODE_F8 \n");
|
|
cipher_key = &ctl_desc->cipherHashInfo.infoAES192F8HMAC.cipherKey0;
|
|
hmac_key = &ctl_desc->cipherHashInfo.infoAES192F8HMAC.hmacKey0;
|
|
cipher_keylen = XLR_SEC_AES192F8_KEY_LENGTH;
|
|
hmac_keylen = sizeof(HMAC_t);
|
|
ctl_size = sizeof(AES192F8HMAC_t);
|
|
break;
|
|
case XLR_SEC_VECTOR__CIPHER_AES192__MODE_F8:
|
|
XLR_SEC_CMD_DIAG("XLR_SEC_VECTOR__CIPHER_AES192__MODE_F8 \n");
|
|
cipher_key = &ctl_desc->cipherHashInfo.infoAES192F8.cipherKey0;
|
|
cipher_keylen = XLR_SEC_AES192F8_KEY_LENGTH;
|
|
ctl_size = sizeof(AES192F8_t);
|
|
break;
|
|
|
|
case XLR_SEC_VECTOR__CIPHER_AES256__HMAC__MODE_CTR_CFB:
|
|
XLR_SEC_CMD_DIAG("XLR_SEC_VECTOR__CIPHER_AES256__HMAC__MODE_CTR_CFB \n");
|
|
cipher_key = &ctl_desc->cipherHashInfo.infoAES256HMAC.cipherKey0;
|
|
hmac_key = &ctl_desc->cipherHashInfo.infoAES256HMAC.hmacKey0;
|
|
cipher_keylen = XLR_SEC_AES256_KEY_LENGTH;
|
|
hmac_keylen = sizeof(HMAC_t);
|
|
ctl_size = sizeof(AES256HMAC_t);
|
|
break;
|
|
case XLR_SEC_VECTOR__CIPHER_AES256__MODE_CTR_CFB:
|
|
XLR_SEC_CMD_DIAG("XLR_SEC_VECTOR__CIPHER_AES256__MODE_CTR_CFB \n");
|
|
cipher_key = &ctl_desc->cipherHashInfo.infoAES256.cipherKey0;
|
|
cipher_keylen = XLR_SEC_AES256_KEY_LENGTH;
|
|
ctl_size = sizeof(AES256_t);
|
|
break;
|
|
case XLR_SEC_VECTOR__CIPHER_AES256__HMAC__MODE_ECB_CBC_OFB:
|
|
XLR_SEC_CMD_DIAG("XLR_SEC_VECTOR__CIPHER_AES256__HMAC__MODE_ECB_CBC_OFB \n");
|
|
cipher_key = &ctl_desc->cipherHashInfo.infoAES256HMAC.cipherKey0;
|
|
hmac_key = &ctl_desc->cipherHashInfo.infoAES256HMAC.hmacKey0;
|
|
cipher_keylen = XLR_SEC_AES256_KEY_LENGTH;
|
|
hmac_keylen = sizeof(HMAC_t);
|
|
ctl_size = sizeof(AES256HMAC_t);
|
|
break;
|
|
case XLR_SEC_VECTOR__CIPHER_AES256__MODE_ECB_CBC_OFB:
|
|
XLR_SEC_CMD_DIAG("XLR_SEC_VECTOR__CIPHER_AES256__MODE_ECB_CBC_OFB \n");
|
|
cipher_key = &ctl_desc->cipherHashInfo.infoAES256.cipherKey0;
|
|
cipher_keylen = XLR_SEC_AES256_KEY_LENGTH;
|
|
ctl_size = sizeof(AES256_t);
|
|
break;
|
|
case XLR_SEC_VECTOR__CIPHER_AES256__HMAC__MODE_F8:
|
|
XLR_SEC_CMD_DIAG("XLR_SEC_VECTOR__CIPHER_AES256__HMAC__MODE_F8 \n");
|
|
cipher_key = &ctl_desc->cipherHashInfo.infoAES256F8HMAC.cipherKey0;
|
|
hmac_key = &ctl_desc->cipherHashInfo.infoAES256F8HMAC.hmacKey0;
|
|
cipher_keylen = XLR_SEC_AES256F8_KEY_LENGTH;
|
|
hmac_keylen = sizeof(HMAC_t);
|
|
ctl_size = sizeof(AES256F8HMAC_t);
|
|
break;
|
|
case XLR_SEC_VECTOR__CIPHER_AES256__MODE_F8:
|
|
XLR_SEC_CMD_DIAG("XLR_SEC_VECTOR__CIPHER_AES256__MODE_F8 \n");
|
|
cipher_key = &ctl_desc->cipherHashInfo.infoAES256F8.cipherKey0;
|
|
cipher_keylen = XLR_SEC_AES256F8_KEY_LENGTH;
|
|
ctl_size = sizeof(AES256F8_t);
|
|
break;
|
|
case XLR_SEC_VECTOR_HMAC2:
|
|
XLR_SEC_CMD_DIAG("XLR_SEC_VECTOR_HMAC2 \n");
|
|
hmac_key = &ctl_desc->cipherHashInfo.infoHMAC2.hmacKey0;
|
|
hmac_keylen = sizeof(HMAC2_t);
|
|
ctl_size = sizeof(HMAC2_t);
|
|
break;
|
|
case XLR_SEC_VECTOR_CIPHER_ARC4__HMAC2:
|
|
XLR_SEC_CMD_DIAG("XLR_SEC_VECTOR_CIPHER_ARC4__HMAC2\n");
|
|
cipher_key = &ctl_desc->cipherHashInfo.infoARC4HMAC2.cipherKey0;
|
|
hmac_key = &ctl_desc->cipherHashInfo.infoARC4HMAC2.hmacKey0;
|
|
cipher_keylen = op->rc4_key_len;
|
|
hmac_keylen = sizeof(HMAC2_t);
|
|
ctl_size = sizeof(ARC4HMAC2_t);
|
|
break;
|
|
case XLR_SEC_VECTOR_CIPHER_ARC4__HMAC2__STATE:
|
|
XLR_SEC_CMD_DIAG("XLR_SEC_VECTOR_CIPHER_ARC4__HMAC2__STATE\n");
|
|
cipher_key = &ctl_desc->cipherHashInfo.infoARC4StateHMAC2.cipherKey0;
|
|
cipher_state =
|
|
&ctl_desc->cipherHashInfo.infoARC4StateHMAC2.Arc4SboxData0;
|
|
hmac_key = &ctl_desc->cipherHashInfo.infoARC4StateHMAC2.hmacKey0;
|
|
cipher_keylen = op->rc4_key_len;
|
|
hmac_keylen = sizeof(HMAC2_t);
|
|
ctl_size = sizeof(ARC4StateHMAC2_t);
|
|
break;
|
|
case XLR_SEC_VECTOR__CIPHER_DES__HMAC2__MODE_ECB_CBC:
|
|
XLR_SEC_CMD_DIAG(" XLR_SEC_VECTOR__CIPHER_DES__HMAC2__MODE_ECB_CBC \n");
|
|
cipher_key = &ctl_desc->cipherHashInfo.infoDESHMAC2.cipherKey0;
|
|
hmac_key = &ctl_desc->cipherHashInfo.infoDESHMAC2.hmacKey0;
|
|
hmac_keylen = sizeof(HMAC2_t);
|
|
cipher_keylen = XLR_SEC_DES_KEY_LENGTH;
|
|
ctl_size = sizeof(DESHMAC2_t);
|
|
break;
|
|
case XLR_SEC_VECTOR__CIPHER_3DES__HMAC2__MODE_ECB_CBC:
|
|
XLR_SEC_CMD_DIAG("XLR_SEC_VECTOR__CIPHER_3DES__HMAC2__MODE_ECB_CBC \n");
|
|
cipher_key = &ctl_desc->cipherHashInfo.info3DESHMAC2.cipherKey0;
|
|
hmac_key = &ctl_desc->cipherHashInfo.info3DESHMAC2.hmacKey0;
|
|
cipher_keylen = XLR_SEC_3DES_KEY_LENGTH;
|
|
hmac_keylen = sizeof(HMAC2_t);
|
|
ctl_size = sizeof(DES3HMAC2_t);
|
|
break;
|
|
case XLR_SEC_VECTOR__CIPHER_AES128__HMAC2__MODE_CTR_CFB:
|
|
XLR_SEC_CMD_DIAG("XLR_SEC_VECTOR__CIPHER_AES128__HMAC2__MODE_CTR_CFB \n");
|
|
cipher_key = &ctl_desc->cipherHashInfo.infoAES128HMAC2.cipherKey0;
|
|
hmac_key = &ctl_desc->cipherHashInfo.infoAES128HMAC2.hmacKey0;
|
|
cipher_keylen = XLR_SEC_AES128_KEY_LENGTH;
|
|
hmac_keylen = sizeof(HMAC2_t);
|
|
ctl_size = sizeof(AES128HMAC2_t);
|
|
break;
|
|
case XLR_SEC_VECTOR__CIPHER_AES128__HMAC2__MODE_ECB_CBC_OFB:
|
|
XLR_SEC_CMD_DIAG(" XLR_SEC_VECTOR__CIPHER_AES128__HMAC2__MODE_ECB_CBC_OFB \n");
|
|
cipher_key = &ctl_desc->cipherHashInfo.infoAES128HMAC2.cipherKey0;
|
|
hmac_key = &ctl_desc->cipherHashInfo.infoAES128HMAC2.hmacKey0;
|
|
cipher_keylen = XLR_SEC_AES128_KEY_LENGTH;
|
|
hmac_keylen = sizeof(HMAC2_t);
|
|
ctl_size = sizeof(AES128HMAC2_t);
|
|
break;
|
|
case XLR_SEC_VECTOR__CIPHER_AES128__HMAC2__MODE_F8:
|
|
XLR_SEC_CMD_DIAG("XLR_SEC_VECTOR__CIPHER_AES128__HMAC2__MODE_F8 \n");
|
|
cipher_key = &ctl_desc->cipherHashInfo.infoAES128F8HMAC2.cipherKey0;
|
|
hmac_key = &ctl_desc->cipherHashInfo.infoAES128F8HMAC2.hmacKey0;
|
|
cipher_keylen = XLR_SEC_AES128F8_KEY_LENGTH;
|
|
hmac_keylen = sizeof(HMAC2_t);
|
|
ctl_size = sizeof(AES128F8HMAC2_t);
|
|
break;
|
|
case XLR_SEC_VECTOR__CIPHER_AES192__HMAC2__MODE_CTR_CFB:
|
|
XLR_SEC_CMD_DIAG("XLR_SEC_VECTOR__CIPHER_AES192__HMAC2__MODE_CTR_CFB \n");
|
|
cipher_key = &ctl_desc->cipherHashInfo.infoAES192HMAC2.cipherKey0;
|
|
hmac_key = &ctl_desc->cipherHashInfo.infoAES192HMAC2.hmacKey0;
|
|
cipher_keylen = XLR_SEC_AES192_KEY_LENGTH;
|
|
hmac_keylen = sizeof(HMAC2_t);
|
|
ctl_size = sizeof(AES192HMAC2_t);
|
|
break;
|
|
case XLR_SEC_VECTOR__CIPHER_AES192__HMAC2__MODE_ECB_CBC_OFB:
|
|
XLR_SEC_CMD_DIAG("XLR_SEC_VECTOR__CIPHER_AES192__HMAC2__MODE_ECB_CBC_OFB \n");
|
|
cipher_key = &ctl_desc->cipherHashInfo.infoAES192HMAC2.cipherKey0;
|
|
hmac_key = &ctl_desc->cipherHashInfo.infoAES192HMAC2.hmacKey0;
|
|
cipher_keylen = XLR_SEC_AES192_KEY_LENGTH;
|
|
hmac_keylen = sizeof(HMAC2_t);
|
|
ctl_size = sizeof(AES192HMAC2_t);
|
|
break;
|
|
case XLR_SEC_VECTOR__CIPHER_AES192__HMAC2__MODE_F8:
|
|
XLR_SEC_CMD_DIAG("XLR_SEC_VECTOR__CIPHER_AES192__HMAC2__MODE_F8 \n");
|
|
cipher_key = &ctl_desc->cipherHashInfo.infoAES192F8HMAC2.cipherKey0;
|
|
hmac_key = &ctl_desc->cipherHashInfo.infoAES192F8HMAC2.hmacKey0;
|
|
cipher_keylen = XLR_SEC_AES192F8_KEY_LENGTH;
|
|
hmac_keylen = sizeof(HMAC2_t);
|
|
ctl_size = sizeof(AES192F8HMAC2_t);
|
|
break;
|
|
case XLR_SEC_VECTOR__CIPHER_AES256__HMAC2__MODE_CTR_CFB:
|
|
XLR_SEC_CMD_DIAG("XLR_SEC_VECTOR__CIPHER_AES256__HMAC2__MODE_CTR_CFB \n");
|
|
cipher_key = &ctl_desc->cipherHashInfo.infoAES256HMAC2.cipherKey0;
|
|
hmac_key = &ctl_desc->cipherHashInfo.infoAES256HMAC2.hmacKey0;
|
|
cipher_keylen = XLR_SEC_AES256_KEY_LENGTH;
|
|
hmac_keylen = sizeof(HMAC2_t);
|
|
ctl_size = sizeof(AES256HMAC2_t);
|
|
break;
|
|
case XLR_SEC_VECTOR__CIPHER_AES256__HMAC2__MODE_ECB_CBC_OFB:
|
|
XLR_SEC_CMD_DIAG("XLR_SEC_VECTOR__CIPHER_AES256__HMAC2__MODE_ECB_CBC_OFB \n");
|
|
cipher_key = &ctl_desc->cipherHashInfo.infoAES256HMAC2.cipherKey0;
|
|
hmac_key = &ctl_desc->cipherHashInfo.infoAES256HMAC2.hmacKey0;
|
|
cipher_keylen = XLR_SEC_AES256_KEY_LENGTH;
|
|
hmac_keylen = sizeof(HMAC2_t);
|
|
ctl_size = sizeof(AES256HMAC2_t);
|
|
break;
|
|
case XLR_SEC_VECTOR__CIPHER_AES256__HMAC2__MODE_F8:
|
|
XLR_SEC_CMD_DIAG("XLR_SEC_VECTOR__CIPHER_AES256__HMAC2__MODE_F8 \n");
|
|
cipher_key = &ctl_desc->cipherHashInfo.infoAES256F8HMAC2.cipherKey0;
|
|
hmac_key = &ctl_desc->cipherHashInfo.infoAES256F8HMAC2.hmacKey0;
|
|
cipher_keylen = XLR_SEC_AES256F8_KEY_LENGTH;
|
|
hmac_keylen = sizeof(HMAC2_t);
|
|
ctl_size = sizeof(AES256F8HMAC2_t);
|
|
break;
|
|
case XLR_SEC_VECTOR_GCM:
|
|
XLR_SEC_CMD_DIAG("XLR_SEC_VECTOR_GCM \n");
|
|
hmac_key = &ctl_desc->cipherHashInfo.infoGCM.GCMH0;
|
|
hmac_keylen = sizeof(GCM_t);
|
|
ctl_size = sizeof(GCM_t);
|
|
break;
|
|
case XLR_SEC_VECTOR_CIPHER_ARC4__GCM:
|
|
XLR_SEC_CMD_DIAG("XLR_SEC_VECTOR_CIPHER_ARC4__GCM\n");
|
|
cipher_key = &ctl_desc->cipherHashInfo.infoARC4GCM.cipherKey0;
|
|
hmac_key = &ctl_desc->cipherHashInfo.infoARC4GCM.GCMH0;
|
|
cipher_keylen = op->rc4_key_len;
|
|
hmac_keylen = sizeof(GCM_t);
|
|
ctl_size = sizeof(ARC4GCM_t);
|
|
break;
|
|
case XLR_SEC_VECTOR_CIPHER_ARC4__GCM__STATE:
|
|
XLR_SEC_CMD_DIAG("XLR_SEC_VECTOR_CIPHER_ARC4__GCM__STATE\n");
|
|
cipher_key = &ctl_desc->cipherHashInfo.infoARC4StateGCM.cipherKey0;
|
|
cipher_state =
|
|
&ctl_desc->cipherHashInfo.infoARC4StateGCM.Arc4SboxData0;
|
|
hmac_key = &ctl_desc->cipherHashInfo.infoARC4StateGCM.GCMH0;
|
|
cipher_keylen = op->rc4_key_len;
|
|
hmac_keylen = sizeof(GCM_t);
|
|
ctl_size = sizeof(ARC4StateGCM_t);
|
|
break;
|
|
case XLR_SEC_VECTOR__CIPHER_DES__GCM__MODE_ECB_CBC:
|
|
XLR_SEC_CMD_DIAG(" XLR_SEC_VECTOR__CIPHER_DES__GCM__MODE_ECB_CBC \n");
|
|
cipher_key = &ctl_desc->cipherHashInfo.infoDESGCM.cipherKey0;
|
|
hmac_key = &ctl_desc->cipherHashInfo.infoDESGCM.GCMH0;
|
|
hmac_keylen = sizeof(GCM_t);
|
|
cipher_keylen = XLR_SEC_DES_KEY_LENGTH;
|
|
ctl_size = sizeof(DESGCM_t);
|
|
break;
|
|
case XLR_SEC_VECTOR__CIPHER_3DES__GCM__MODE_ECB_CBC:
|
|
XLR_SEC_CMD_DIAG("XLR_SEC_VECTOR__CIPHER_3DES__GCM__MODE_ECB_CBC \n");
|
|
cipher_key = &ctl_desc->cipherHashInfo.info3DESGCM.cipherKey0;
|
|
hmac_key = &ctl_desc->cipherHashInfo.info3DESGCM.GCMH0;
|
|
cipher_keylen = XLR_SEC_3DES_KEY_LENGTH;
|
|
hmac_keylen = sizeof(GCM_t);
|
|
ctl_size = sizeof(DES3GCM_t);
|
|
break;
|
|
case XLR_SEC_VECTOR__CIPHER_AES128__GCM__MODE_CTR_CFB:
|
|
XLR_SEC_CMD_DIAG("XLR_SEC_VECTOR__CIPHER_AES128__GCM__MODE_CTR_CFB \n");
|
|
cipher_key = &ctl_desc->cipherHashInfo.infoAES128GCM.cipherKey0;
|
|
hmac_key = &ctl_desc->cipherHashInfo.infoAES128GCM.GCMH0;
|
|
cipher_keylen = XLR_SEC_AES128_KEY_LENGTH;
|
|
hmac_keylen = sizeof(GCM_t);
|
|
ctl_size = sizeof(AES128GCM_t);
|
|
break;
|
|
case XLR_SEC_VECTOR__CIPHER_AES128__GCM__MODE_ECB_CBC_OFB:
|
|
XLR_SEC_CMD_DIAG(" XLR_SEC_VECTOR__CIPHER_AES128__GCM__MODE_ECB_CBC_OFB \n");
|
|
cipher_key = &ctl_desc->cipherHashInfo.infoAES128GCM.cipherKey0;
|
|
hmac_key = &ctl_desc->cipherHashInfo.infoAES128GCM.GCMH0;
|
|
cipher_keylen = XLR_SEC_AES128_KEY_LENGTH;
|
|
hmac_keylen = sizeof(GCM_t);
|
|
ctl_size = sizeof(AES128GCM_t);
|
|
break;
|
|
case XLR_SEC_VECTOR__CIPHER_AES128__GCM__MODE_F8:
|
|
XLR_SEC_CMD_DIAG("XLR_SEC_VECTOR__CIPHER_AES128__GCM__MODE_F8 \n");
|
|
cipher_key = &ctl_desc->cipherHashInfo.infoAES128F8GCM.cipherKey0;
|
|
hmac_key = &ctl_desc->cipherHashInfo.infoAES128F8GCM.GCMH0;
|
|
cipher_keylen = XLR_SEC_AES128F8_KEY_LENGTH;
|
|
hmac_keylen = sizeof(GCM_t);
|
|
ctl_size = sizeof(AES128F8GCM_t);
|
|
break;
|
|
case XLR_SEC_VECTOR__CIPHER_AES192__GCM__MODE_CTR_CFB:
|
|
XLR_SEC_CMD_DIAG("XLR_SEC_VECTOR__CIPHER_AES192__GCM__MODE_CTR_CFB \n");
|
|
cipher_key = &ctl_desc->cipherHashInfo.infoAES192GCM.cipherKey0;
|
|
hmac_key = &ctl_desc->cipherHashInfo.infoAES192GCM.GCMH0;
|
|
cipher_keylen = XLR_SEC_AES192_KEY_LENGTH;
|
|
hmac_keylen = sizeof(GCM_t);
|
|
ctl_size = sizeof(AES192GCM_t);
|
|
break;
|
|
case XLR_SEC_VECTOR__CIPHER_AES192__GCM__MODE_ECB_CBC_OFB:
|
|
XLR_SEC_CMD_DIAG("XLR_SEC_VECTOR__CIPHER_AES192__GCM__MODE_ECB_CBC_OFB \n");
|
|
cipher_key = &ctl_desc->cipherHashInfo.infoAES192GCM.cipherKey0;
|
|
hmac_key = &ctl_desc->cipherHashInfo.infoAES192GCM.GCMH0;
|
|
cipher_keylen = XLR_SEC_AES192_KEY_LENGTH;
|
|
hmac_keylen = sizeof(GCM_t);
|
|
ctl_size = sizeof(AES192GCM_t);
|
|
break;
|
|
case XLR_SEC_VECTOR__CIPHER_AES192__GCM__MODE_F8:
|
|
XLR_SEC_CMD_DIAG("XLR_SEC_VECTOR__CIPHER_AES192__GCM__MODE_F8 \n");
|
|
cipher_key = &ctl_desc->cipherHashInfo.infoAES192F8GCM.cipherKey0;
|
|
hmac_key = &ctl_desc->cipherHashInfo.infoAES192F8GCM.GCMH0;
|
|
cipher_keylen = XLR_SEC_AES192F8_KEY_LENGTH;
|
|
hmac_keylen = sizeof(GCM_t);
|
|
ctl_size = sizeof(AES192F8GCM_t);
|
|
break;
|
|
case XLR_SEC_VECTOR__CIPHER_AES256__GCM__MODE_CTR_CFB:
|
|
XLR_SEC_CMD_DIAG("XLR_SEC_VECTOR__CIPHER_AES256__GCM__MODE_CTR_CFB \n");
|
|
cipher_key = &ctl_desc->cipherHashInfo.infoAES256GCM.cipherKey0;
|
|
hmac_key = &ctl_desc->cipherHashInfo.infoAES256GCM.GCMH0;
|
|
cipher_keylen = XLR_SEC_AES256_KEY_LENGTH;
|
|
hmac_keylen = sizeof(GCM_t);
|
|
ctl_size = sizeof(AES256GCM_t);
|
|
break;
|
|
case XLR_SEC_VECTOR__CIPHER_AES256__GCM__MODE_ECB_CBC_OFB:
|
|
XLR_SEC_CMD_DIAG("XLR_SEC_VECTOR__CIPHER_AES256__GCM__MODE_ECB_CBC_OFB \n");
|
|
cipher_key = &ctl_desc->cipherHashInfo.infoAES256GCM.cipherKey0;
|
|
hmac_key = &ctl_desc->cipherHashInfo.infoAES256GCM.GCMH0;
|
|
cipher_keylen = XLR_SEC_AES256_KEY_LENGTH;
|
|
hmac_keylen = sizeof(GCM_t);
|
|
ctl_size = sizeof(AES256GCM_t);
|
|
break;
|
|
case XLR_SEC_VECTOR__CIPHER_AES256__GCM__MODE_F8:
|
|
XLR_SEC_CMD_DIAG("XLR_SEC_VECTOR__CIPHER_AES256__GCM__MODE_F8 \n");
|
|
cipher_key = &ctl_desc->cipherHashInfo.infoAES256F8GCM.cipherKey0;
|
|
hmac_key = &ctl_desc->cipherHashInfo.infoAES256F8GCM.GCMH0;
|
|
cipher_keylen = XLR_SEC_AES256F8_KEY_LENGTH;
|
|
hmac_keylen = sizeof(GCM_t);
|
|
ctl_size = sizeof(AES256F8GCM_t);
|
|
break;
|
|
case XLR_SEC_VECTOR_F9:
|
|
XLR_SEC_CMD_DIAG("XLR_SEC_VECTOR_F9 \n");
|
|
hmac_key = &ctl_desc->cipherHashInfo.infoF9.authKey0;
|
|
hmac_keylen = sizeof(F9_t);
|
|
ctl_size = sizeof(F9_t);
|
|
break;
|
|
case XLR_SEC_VECTOR_CIPHER_ARC4__F9:
|
|
XLR_SEC_CMD_DIAG("XLR_SEC_VECTOR_CIPHER_ARC4__F9\n");
|
|
cipher_key = &ctl_desc->cipherHashInfo.infoARC4F9.cipherKey0;
|
|
hmac_key = &ctl_desc->cipherHashInfo.infoARC4F9.authKey0;
|
|
cipher_keylen = op->rc4_key_len;
|
|
hmac_keylen = sizeof(F9_t);
|
|
ctl_size = sizeof(ARC4F9_t);
|
|
break;
|
|
case XLR_SEC_VECTOR_CIPHER_ARC4__F9__STATE:
|
|
XLR_SEC_CMD_DIAG("XLR_SEC_VECTOR_CIPHER_ARC4__F9__STATE\n");
|
|
cipher_key = &ctl_desc->cipherHashInfo.infoARC4StateF9.cipherKey0;
|
|
cipher_state =
|
|
&ctl_desc->cipherHashInfo.infoARC4StateF9.Arc4SboxData0;
|
|
hmac_key = &ctl_desc->cipherHashInfo.infoARC4StateF9.authKey0;
|
|
cipher_keylen = op->rc4_key_len;
|
|
hmac_keylen = sizeof(F9_t);
|
|
ctl_size = sizeof(ARC4StateF9_t);
|
|
break;
|
|
case XLR_SEC_VECTOR__CIPHER_DES__F9__MODE_ECB_CBC:
|
|
XLR_SEC_CMD_DIAG(" XLR_SEC_VECTOR__CIPHER_DES__F9__MODE_ECB_CBC \n");
|
|
cipher_key = &ctl_desc->cipherHashInfo.infoDESF9.cipherKey0;
|
|
hmac_key = &ctl_desc->cipherHashInfo.infoDESF9.authKey0;
|
|
hmac_keylen = sizeof(F9_t);
|
|
cipher_keylen = XLR_SEC_DES_KEY_LENGTH;
|
|
ctl_size = sizeof(DESF9_t);
|
|
break;
|
|
case XLR_SEC_VECTOR__CIPHER_3DES__F9__MODE_ECB_CBC:
|
|
XLR_SEC_CMD_DIAG("XLR_SEC_VECTOR__CIPHER_3DES__F9__MODE_ECB_CBC \n");
|
|
cipher_key = &ctl_desc->cipherHashInfo.info3DESF9.cipherKey0;
|
|
hmac_key = &ctl_desc->cipherHashInfo.info3DESF9.authKey0;
|
|
cipher_keylen = XLR_SEC_3DES_KEY_LENGTH;
|
|
hmac_keylen = sizeof(F9_t);
|
|
ctl_size = sizeof(DES3F9_t);
|
|
break;
|
|
case XLR_SEC_VECTOR__CIPHER_AES128__F9__MODE_CTR_CFB:
|
|
XLR_SEC_CMD_DIAG("XLR_SEC_VECTOR__CIPHER_AES128__F9__MODE_CTR_CFB \n");
|
|
cipher_key = &ctl_desc->cipherHashInfo.infoAES128F9.cipherKey0;
|
|
hmac_key = &ctl_desc->cipherHashInfo.infoAES128F9.authKey0;
|
|
cipher_keylen = XLR_SEC_AES128_KEY_LENGTH;
|
|
hmac_keylen = sizeof(F9_t);
|
|
ctl_size = sizeof(AES128F9_t);
|
|
break;
|
|
case XLR_SEC_VECTOR__CIPHER_AES128__F9__MODE_ECB_CBC_OFB:
|
|
XLR_SEC_CMD_DIAG(" XLR_SEC_VECTOR__CIPHER_AES128__F9__MODE_ECB_CBC_OFB \n");
|
|
cipher_key = &ctl_desc->cipherHashInfo.infoAES128F9.cipherKey0;
|
|
hmac_key = &ctl_desc->cipherHashInfo.infoAES128F9.authKey0;
|
|
cipher_keylen = XLR_SEC_AES128_KEY_LENGTH;
|
|
hmac_keylen = sizeof(F9_t);
|
|
ctl_size = sizeof(AES128F9_t);
|
|
break;
|
|
case XLR_SEC_VECTOR__CIPHER_AES128__F9__MODE_F8:
|
|
XLR_SEC_CMD_DIAG("XLR_SEC_VECTOR__CIPHER_AES128__F9__MODE_F8 \n");
|
|
cipher_key = &ctl_desc->cipherHashInfo.infoAES128F8F9.cipherKey0;
|
|
hmac_key = &ctl_desc->cipherHashInfo.infoAES128F8F9.authKey0;
|
|
cipher_keylen = XLR_SEC_AES128F8_KEY_LENGTH;
|
|
hmac_keylen = sizeof(F9_t);
|
|
ctl_size = sizeof(AES128F8F9_t);
|
|
break;
|
|
case XLR_SEC_VECTOR__CIPHER_AES192__F9__MODE_CTR_CFB:
|
|
XLR_SEC_CMD_DIAG("XLR_SEC_VECTOR__CIPHER_AES192__F9__MODE_CTR_CFB \n");
|
|
cipher_key = &ctl_desc->cipherHashInfo.infoAES192F9.cipherKey0;
|
|
hmac_key = &ctl_desc->cipherHashInfo.infoAES192F9.authKey0;
|
|
cipher_keylen = XLR_SEC_AES192_KEY_LENGTH;
|
|
hmac_keylen = sizeof(F9_t);
|
|
ctl_size = sizeof(AES192F9_t);
|
|
break;
|
|
case XLR_SEC_VECTOR__CIPHER_AES192__F9__MODE_ECB_CBC_OFB:
|
|
XLR_SEC_CMD_DIAG("XLR_SEC_VECTOR__CIPHER_AES192__F9__MODE_ECB_CBC_OFB \n");
|
|
cipher_key = &ctl_desc->cipherHashInfo.infoAES192F9.cipherKey0;
|
|
hmac_key = &ctl_desc->cipherHashInfo.infoAES192F9.authKey0;
|
|
cipher_keylen = XLR_SEC_AES192_KEY_LENGTH;
|
|
hmac_keylen = sizeof(F9_t);
|
|
ctl_size = sizeof(AES192F9_t);
|
|
break;
|
|
case XLR_SEC_VECTOR__CIPHER_AES192__F9__MODE_F8:
|
|
XLR_SEC_CMD_DIAG("XLR_SEC_VECTOR__CIPHER_AES192__F9__MODE_F8 \n");
|
|
cipher_key = &ctl_desc->cipherHashInfo.infoAES192F8F9.cipherKey0;
|
|
hmac_key = &ctl_desc->cipherHashInfo.infoAES192F8F9.authKey0;
|
|
cipher_keylen = XLR_SEC_AES192F8_KEY_LENGTH;
|
|
hmac_keylen = sizeof(F9_t);
|
|
ctl_size = sizeof(AES192F8F9_t);
|
|
break;
|
|
case XLR_SEC_VECTOR__CIPHER_AES256__F9__MODE_CTR_CFB:
|
|
XLR_SEC_CMD_DIAG("XLR_SEC_VECTOR__CIPHER_AES256__F9__MODE_CTR_CFB \n");
|
|
cipher_key = &ctl_desc->cipherHashInfo.infoAES256F9.cipherKey0;
|
|
hmac_key = &ctl_desc->cipherHashInfo.infoAES256F9.authKey0;
|
|
cipher_keylen = XLR_SEC_AES256_KEY_LENGTH;
|
|
hmac_keylen = sizeof(F9_t);
|
|
ctl_size = sizeof(AES256F9_t);
|
|
break;
|
|
case XLR_SEC_VECTOR__CIPHER_AES256__F9__MODE_ECB_CBC_OFB:
|
|
XLR_SEC_CMD_DIAG("XLR_SEC_VECTOR__CIPHER_AES256__F9__MODE_ECB_CBC_OFB \n");
|
|
cipher_key = &ctl_desc->cipherHashInfo.infoAES256F9.cipherKey0;
|
|
hmac_key = &ctl_desc->cipherHashInfo.infoAES256F9.authKey0;
|
|
cipher_keylen = XLR_SEC_AES256_KEY_LENGTH;
|
|
hmac_keylen = sizeof(F9_t);
|
|
ctl_size = sizeof(AES256F9_t);
|
|
break;
|
|
case XLR_SEC_VECTOR__CIPHER_AES256__F9__MODE_F8:
|
|
XLR_SEC_CMD_DIAG("XLR_SEC_VECTOR__CIPHER_AES256__F9__MODE_F8 \n");
|
|
cipher_key = &ctl_desc->cipherHashInfo.infoAES256F8F9.cipherKey0;
|
|
hmac_key = &ctl_desc->cipherHashInfo.infoAES256F8F9.authKey0;
|
|
cipher_keylen = XLR_SEC_AES256F8_KEY_LENGTH;
|
|
hmac_keylen = sizeof(F9_t);
|
|
ctl_size = sizeof(AES256F8F9_t);
|
|
break;
|
|
|
|
default:
|
|
XLR_SEC_CMD_DIAG("default \n");
|
|
return XLR_SEC_ERR_CONTROL_VECTOR;
|
|
}
|
|
|
|
if ((cipher_key != NULL) && !(flags & XLR_SEC_SETUP_OP_PRESERVE_CIPHER_KEY))
|
|
memcpy(cipher_key, &op->crypt_key[0], cipher_keylen);
|
|
|
|
if ((hmac_key != NULL) && !(flags & XLR_SEC_SETUP_OP_PRESERVE_HMAC_KEY))
|
|
memcpy(hmac_key, &op->mac_key[0], hmac_keylen);
|
|
if (cipher_state) {
|
|
if (op->rc4_loadstate)
|
|
memcpy(cipher_state, (void *)(unsigned long)op->rc4_state,
|
|
XLR_SEC_MAX_RC4_STATE_SIZE);
|
|
if (op->rc4_savestate)
|
|
user->aligned_state = (char *)cipher_state;
|
|
}
|
|
if (flags & XLR_SEC_SETUP_OP_FLIP_3DES_KEY) {
|
|
uint64_t temp;
|
|
|
|
temp = ctl_desc->cipherHashInfo.info3DES.cipherKey0;
|
|
ctl_desc->cipherHashInfo.info3DES.cipherKey0 =
|
|
ctl_desc->cipherHashInfo.info3DES.cipherKey2;
|
|
ctl_desc->cipherHashInfo.info3DES.cipherKey2 = temp;
|
|
}
|
|
/*
|
|
* Control length is the number of control cachelines to be read so
|
|
* user needs to round up the control length to closest integer
|
|
* multiple of 32 bytes.
|
|
*/
|
|
ctl_size += sizeof(ctl_desc->instruction);
|
|
ctl_len = NUM_CHUNKS(ctl_size, 5);
|
|
XLR_SEC_CMD_DIAG("ctl_size in bytes: %u, in cachelines: %u\n", ctl_size, ctl_len);
|
|
CLEAR_SET_FIELD(*control, MSG_CMD_CTL_LEN, ctl_len);
|
|
|
|
ctl_addr = (uint64_t) vtophys(ctl_desc);
|
|
CLEAR_SET_FIELD(*control, MSG_CMD_CTL_ADDR, ctl_addr);
|
|
|
|
XLR_SEC_CMD_DIAG(" xlr_sec_control_setup(): ctl_desc=%p ctl_addr=%llx \n",
|
|
ctl_desc, (unsigned long long)ctl_addr);
|
|
|
|
CLEAR_SET_FIELD(*control, MSG_CMD_CTL_CTL, SEC_SOP);
|
|
|
|
return XLR_SEC_ERR_NONE;
|
|
}
|
|
|
|
|
|
xlr_sec_error_t
|
|
xlr_sec_submit_op(symkey_desc_pt desc)
|
|
{
|
|
struct msgrng_msg send_msg;
|
|
|
|
int rsp_dest_id, cpu, hard_cpu, hard_thread;
|
|
int code, retries;
|
|
unsigned long msgrng_flags = 0;
|
|
|
|
/* threads (0-3) are orthogonal to buckets 0-3 */
|
|
cpu = xlr_cpu_id();
|
|
|
|
hard_cpu = cpu >> 2;
|
|
hard_thread = cpu & 0x3;/* thread id */
|
|
rsp_dest_id = (hard_cpu << 3) + hard_thread;
|
|
|
|
desc->op_ctl.cpu = hard_cpu;
|
|
desc->op_ctl.flags = 0; /* called from kernel thread */
|
|
|
|
XLR_SEC_CMD_DIAG("[%s]:%d: cpu=0x%x hard_cpu=0x%x hard_thrd=0x%x id=0x%x \n",
|
|
__FUNCTION__, __LINE__, cpu, hard_cpu, hard_thread, rsp_dest_id);
|
|
|
|
/*
|
|
* Set DestId in Message Control Word. This tells the Security
|
|
* Engine which bucket to send the reply to for this CPU
|
|
*/
|
|
CLEAR_SET_FIELD(desc->control, MSG_CMD_CTL_ID, rsp_dest_id);
|
|
CLEAR_SET_FIELD(desc->data, MSG_CMD_CTL_ID, rsp_dest_id);
|
|
|
|
CLEAR_SET_FIELD(desc->control, MSG_CTL_OP_TYPE, MSG0_CTL_OP_ENGINE_SYMKEY);
|
|
CLEAR_SET_FIELD(desc->data, MSG_CTL_OP_TYPE, MSG1_CTL_OP_SYMKEY_PIPE0);
|
|
|
|
send_msg.msg0 = desc->control | (1ULL << 53);
|
|
send_msg.msg1 = desc->data | (1ULL << 53) | (1ULL << 52);
|
|
send_msg.msg2 = send_msg.msg3 = 0;
|
|
|
|
desc->op_ctl.flags = 1;
|
|
//in_interrupt(); /* ipsec softirq ? */
|
|
|
|
XLR_SEC_CMD_DIAG("[%s]: IN_IRQ=%d msg0=0x%llx msg1=0x%llx \n",
|
|
__FUNCTION__, desc->op_ctl.flags, send_msg.msg0, send_msg.msg1);
|
|
|
|
|
|
|
|
retries = 100;
|
|
|
|
while (retries--) {
|
|
msgrng_flags_save(msgrng_flags);
|
|
|
|
code = message_send_retry(SEC_MSGRING_WORDSIZE,
|
|
MSGRNG_CODE_SEC,
|
|
desc->op_ctl.stn_id,
|
|
&send_msg);
|
|
|
|
|
|
msgrng_flags_restore(msgrng_flags);
|
|
|
|
if (code == 0)
|
|
break;
|
|
}
|
|
|
|
|
|
return (XLR_SEC_ERR_NONE);
|
|
}
|
|
|
|
|
|
|
|
symkey_desc_pt
|
|
xlr_sec_allocate_desc(void *session_ptr)
|
|
{
|
|
uint64_t addr;
|
|
symkey_desc_pt aligned, new;
|
|
|
|
new = (symkey_desc_pt) malloc(sizeof(symkey_desc_t),
|
|
M_DEVBUF, M_NOWAIT | M_ZERO);
|
|
|
|
if (new == NULL)
|
|
return (NULL);
|
|
|
|
new->ses = session_ptr;
|
|
|
|
new->user.kern_src = new->user.aligned_src =
|
|
(uint8_t *) contigmalloc(256 * 1024 + 1024,
|
|
M_DEVBUF, M_NOWAIT | M_ZERO,
|
|
0, 0xffffffff, XLR_CACHELINE_SIZE, 0);
|
|
|
|
if (new->user.kern_src == NULL) {
|
|
printf("ERROR - malloc failed for user.kern_src\n");
|
|
return NULL;
|
|
}
|
|
new->user.aligned_dest = new->user.kern_dest =
|
|
(uint8_t *) contigmalloc(257 * 1024,
|
|
M_DEVBUF, M_NOWAIT | M_ZERO,
|
|
0, 0xffffffff, XLR_CACHELINE_SIZE, 0);
|
|
|
|
if (new->user.aligned_dest == NULL) {
|
|
printf("ERROR - malloc failed for user.aligned_dest\n");
|
|
return NULL;
|
|
}
|
|
new->next_src_buf = (uint8_t *) contigmalloc(256 * 1024 + 1024,
|
|
M_DEVBUF, M_NOWAIT | M_ZERO,
|
|
0, 0xffffffff, XLR_CACHELINE_SIZE, 0);
|
|
|
|
if (new->next_src_buf == NULL) {
|
|
printf("ERROR - malloc failed for next_src_buf\n");
|
|
return NULL;
|
|
}
|
|
new->next_dest_buf =
|
|
(uint8_t *) contigmalloc(257 * 1024,
|
|
M_DEVBUF, M_NOWAIT | M_ZERO,
|
|
0, 0xffffffff, XLR_CACHELINE_SIZE, 0);
|
|
|
|
if (new->next_dest_buf == NULL) {
|
|
printf("ERROR - malloc failed for next_dest_buf\n");
|
|
return NULL;
|
|
}
|
|
new->user.kern_auth = new->user.user_auth = NULL;
|
|
new->user.aligned_auth = new->user.user_auth = NULL;
|
|
|
|
|
|
/* find cacheline alignment */
|
|
aligned = new;
|
|
addr = (uint64_t) vtophys(new);
|
|
|
|
/* save for free */
|
|
aligned->alloc = new;
|
|
|
|
/* setup common control info */
|
|
aligned->op_ctl.phys_self = addr;
|
|
aligned->op_ctl.stn_id = MSGRNG_STNID_SEC0;
|
|
|
|
return (aligned);
|
|
}
|
|
|
|
|
|
static void
|
|
xlr_sec_free_desc(symkey_desc_pt desc)
|
|
{
|
|
if ((desc == NULL) || (desc->alloc == NULL)) {
|
|
printf("%s: NULL descriptor \n", __FUNCTION__);
|
|
return;
|
|
}
|
|
contigfree(desc, sizeof(symkey_desc_t), M_DEVBUF);
|
|
|
|
|
|
return;
|
|
}
|
|
|
|
void
|
|
print_buf(char *desc, void *data, int len)
|
|
{
|
|
uint8_t *dp;
|
|
int i;
|
|
|
|
DPRINT("%s: ", desc); /* newline done in for-loop */
|
|
dp = data;
|
|
for (i = 0; i < len; i++, dp++) {
|
|
if ((i % 16) == 0)
|
|
DPRINT("\n");
|
|
DPRINT(" %c%c",
|
|
nib2hex[(((*dp) & 0xf0) >> 4)],
|
|
nib2hex[((*dp) & 0x0f)]);
|
|
}
|
|
DPRINT("\n");
|
|
}
|
|
|
|
|
|
#ifdef XLR_SEC_CMD_DEBUG
|
|
static void
|
|
decode_symkey_desc(symkey_desc_pt desc, uint32_t cfg_vector)
|
|
{
|
|
|
|
unsigned long long word;
|
|
|
|
/* uint8_t *info; */
|
|
/* int i; */
|
|
|
|
DPRINT("MSG - CTL: \n");
|
|
DPRINT("\t CTRL = %lld \n",
|
|
GET_FIELD(desc->control, MSG_CMD_CTL_CTL));
|
|
DPRINT("\t CTRL LEN = %lld \n",
|
|
GET_FIELD(desc->control, MSG_CMD_CTL_LEN));
|
|
DPRINT("\t CTRL ADDR = %llx \n\n",
|
|
GET_FIELD(desc->control, MSG_CMD_CTL_ADDR));
|
|
|
|
DPRINT("MSG - DATA: \n");
|
|
DPRINT("\t CTRL = %lld \n",
|
|
GET_FIELD(desc->data, MSG_CMD_DATA_CTL));
|
|
DPRINT("\t DATA LEN = %lld \n",
|
|
GET_FIELD(desc->data, MSG_CMD_DATA_LEN));
|
|
DPRINT("\t DATA ADDR = %llx \n\n",
|
|
GET_FIELD(desc->data, MSG_CMD_DATA_ADDR));
|
|
|
|
DPRINT("CONTROL DESCRIPTOR: \n");
|
|
word = desc->ctl_desc.instruction;
|
|
DPRINT("\tINSTRUCTION: %llx\n", word);
|
|
DPRINT("\t\tOVERRIDE CIPH = %lld \n", GET_FIELD(word, CTL_DSC_OVERRIDECIPHER));
|
|
DPRINT("\t\tARC4 WAIT = %lld \n", GET_FIELD(word, CTL_DSC_ARC4_WAIT4SAVE));
|
|
DPRINT("\t\tARC4 SAVE = %lld \n", GET_FIELD(word, CTL_DSC_ARC4_SAVESTATE));
|
|
DPRINT("\t\tARC4 LOAD = %lld \n", GET_FIELD(word, CTL_DSC_ARC4_LOADSTATE));
|
|
DPRINT("\t\tARC4 KEYLEN = %lld \n", GET_FIELD(word, CTL_DSC_ARC4_KEYLEN));
|
|
DPRINT("\t\tCIPHER = %lld \n", GET_FIELD(word, CTL_DSC_CPHR));
|
|
DPRINT("\t\tCIPHER MODE = %lld \n", GET_FIELD(word, CTL_DSC_MODE));
|
|
DPRINT("\t\tINIT CIPHER = %lld \n", GET_FIELD(word, CTL_DSC_ICPHR));
|
|
DPRINT("\t\tHMAC = %lld \n", GET_FIELD(word, CTL_DSC_HMAC));
|
|
DPRINT("\t\tHASH ALG = %lld \n", GET_FIELD(word, CTL_DSC_HASH) | (GET_FIELD(word, CTL_DSC_HASHHI) << 2));
|
|
DPRINT("\t\tINIT HASH = %lld \n", GET_FIELD(word, CTL_DSC_IHASH));
|
|
DPRINT("\t\tCHKSUM = %lld \n", GET_FIELD(word, CTL_DSC_CKSUM));
|
|
DPRINT("\tCIPHER HASH INFO: \n");
|
|
#if 0
|
|
info = (uint8_t *) & desc->ctl_desc->cipherHashInfo;
|
|
for (i = 0; i < sizeof(CipherHashInfo_t); i++, info++) {
|
|
DPRINT(" %02x", *info);
|
|
if (i && (i % 16) == 0)
|
|
DPRINT("\n");
|
|
}
|
|
DPRINT("\n\n");
|
|
#endif
|
|
|
|
switch (cfg_vector) {
|
|
case XLR_SEC_VECTOR_CIPHER_ARC4:
|
|
DPRINT("VECTOR: XLR_SEC_VECTOR_CIPHER_ARC4 \n");
|
|
print_buf("ARC4 Key",
|
|
&desc->ctl_desc.cipherHashInfo.infoARC4.cipherKey0,
|
|
GET_FIELD(word, CTL_DSC_ARC4_KEYLEN));
|
|
break;
|
|
case XLR_SEC_VECTOR_CIPHER_ARC4__HMAC:
|
|
DPRINT("VECTOR: XLR_SEC_VECTOR_CIPHER_ARC4__HMAC \n");
|
|
print_buf("ARC4 Key",
|
|
&desc->ctl_desc.cipherHashInfo.infoARC4HMAC.cipherKey0,
|
|
GET_FIELD(word, CTL_DSC_ARC4_KEYLEN));
|
|
print_buf("HMAC Key",
|
|
&desc->ctl_desc.cipherHashInfo.infoARC4HMAC.hmacKey0,
|
|
sizeof(HMAC_t));
|
|
break;
|
|
case XLR_SEC_VECTOR_CIPHER_ARC4__STATE:
|
|
DPRINT("VECTOR: XLR_SEC_VECTOR_CIPHER_ARC4__STATE \n");
|
|
print_buf("ARC4 Key",
|
|
&desc->ctl_desc.cipherHashInfo.infoARC4State.cipherKey0,
|
|
GET_FIELD(word, CTL_DSC_ARC4_KEYLEN));
|
|
break;
|
|
case XLR_SEC_VECTOR_CIPHER_ARC4__HMAC__STATE:
|
|
DPRINT("VECTOR: XLR_SEC_VECTOR_CIPHER_ARC4__HMAC__STATE \n");
|
|
print_buf("ARC4 Key",
|
|
&desc->ctl_desc.cipherHashInfo.infoARC4StateHMAC.cipherKey0,
|
|
GET_FIELD(word, CTL_DSC_ARC4_KEYLEN));
|
|
print_buf("HMAC Key",
|
|
&desc->ctl_desc.cipherHashInfo.infoARC4StateHMAC.hmacKey0,
|
|
sizeof(HMAC_t));
|
|
break;
|
|
case XLR_SEC_VECTOR_CIPHER_KASUMI_F8:
|
|
DPRINT("VECTOR: XLR_SEC_VECTOR_CIPHER_KASUMI_F8 \n");
|
|
print_buf("KASUMI_F8 Key",
|
|
&desc->ctl_desc.cipherHashInfo.infoKASUMIF8.cipherKey0,
|
|
XLR_SEC_KASUMI_F8_KEY_LENGTH);
|
|
break;
|
|
case XLR_SEC_VECTOR_CIPHER_KASUMI_F8__HMAC:
|
|
DPRINT("XLR_SEC_VECTOR_CIPHER_KASUMI_F8__HMAC\n");
|
|
print_buf("KASUMI_F8 Key",
|
|
&desc->ctl_desc.cipherHashInfo.infoKASUMIF8HMAC.cipherKey0,
|
|
XLR_SEC_KASUMI_F8_KEY_LENGTH);
|
|
print_buf("HMAC Key",
|
|
&desc->ctl_desc.cipherHashInfo.infoKASUMIF8HMAC.hmacKey0,
|
|
sizeof(HMAC_t));
|
|
break;
|
|
case XLR_SEC_VECTOR_CIPHER_KASUMI_F8__HMAC2:
|
|
DPRINT("XLR_SEC_VECTOR_CIPHER_KASUMI_F8__HMAC2\n");
|
|
print_buf("KASUMI_F8 Key",
|
|
&desc->ctl_desc.cipherHashInfo.infoKASUMIF8HMAC2.cipherKey0,
|
|
XLR_SEC_KASUMI_F8_KEY_LENGTH);
|
|
print_buf("HMAC2 Key",
|
|
&desc->ctl_desc.cipherHashInfo.infoKASUMIF8HMAC2.hmacKey0,
|
|
sizeof(HMAC2_t));
|
|
break;
|
|
case XLR_SEC_VECTOR_CIPHER_KASUMI_F8__GCM:
|
|
DPRINT("XLR_SEC_VECTOR_CIPHER_KASUMI_F8__GCM\n");
|
|
print_buf("KASUMI_F8 Key",
|
|
&desc->ctl_desc.cipherHashInfo.infoKASUMIF8GCM.cipherKey0,
|
|
XLR_SEC_KASUMI_F8_KEY_LENGTH);
|
|
print_buf("GCM Key",
|
|
&desc->ctl_desc.cipherHashInfo.infoKASUMIF8GCM.GCMH0,
|
|
sizeof(GCM_t));
|
|
break;
|
|
case XLR_SEC_VECTOR_CIPHER_KASUMI_F8__F9:
|
|
DPRINT("XLR_SEC_VECTOR_CIPHER_KASUMI_F8__F9\n");
|
|
print_buf("KASUMI_F8 Key",
|
|
&desc->ctl_desc.cipherHashInfo.infoKASUMIF8F9.cipherKey0,
|
|
XLR_SEC_KASUMI_F8_KEY_LENGTH);
|
|
print_buf("F9 Key",
|
|
&desc->ctl_desc.cipherHashInfo.infoKASUMIF8F9.authKey0,
|
|
sizeof(F9_t));
|
|
break;
|
|
case XLR_SEC_VECTOR_MAC:
|
|
DPRINT("VECTOR: XLR_SEC_VECTOR_MAC \n");
|
|
DPRINT("MAC-ONLY - No Info\n");
|
|
break;
|
|
case XLR_SEC_VECTOR_HMAC:
|
|
DPRINT("VECTOR: XLR_SEC_VECTOR_HMAC \n");
|
|
print_buf("HMAC Key",
|
|
&desc->ctl_desc.cipherHashInfo.infoHMAC.hmacKey0,
|
|
sizeof(HMAC_t));
|
|
break;
|
|
case XLR_SEC_VECTOR__CIPHER_DES__HMAC__MODE_ECB_CBC:
|
|
DPRINT("VECTOR: XLR_SEC_VECTOR__CIPHER_DES__HMAC__MODE_ECB_CBC \n");
|
|
print_buf("CIPHER Key",
|
|
&desc->ctl_desc.cipherHashInfo.infoDESHMAC.cipherKey0,
|
|
XLR_SEC_DES_KEY_LENGTH);
|
|
print_buf("HMAC Key",
|
|
&desc->ctl_desc.cipherHashInfo.infoDESHMAC.hmacKey0,
|
|
sizeof(HMAC_t));
|
|
break;
|
|
case XLR_SEC_VECTOR__CIPHER_DES__MODE_ECB_CBC:
|
|
DPRINT("VECTOR: XLR_SEC_VECTOR__CIPHER_DES__MODE_ECB_CBC \n");
|
|
print_buf("CIPHER Key",
|
|
&desc->ctl_desc.cipherHashInfo.infoDES.cipherKey0,
|
|
XLR_SEC_DES_KEY_LENGTH);
|
|
break;
|
|
case XLR_SEC_VECTOR__CIPHER_3DES__HMAC__MODE_ECB_CBC:
|
|
DPRINT("VECTOR: XLR_SEC_VECTOR__CIPHER_3DES__HMAC__MODE_ECB_CBC \n");
|
|
print_buf("CIPHER Key",
|
|
&desc->ctl_desc.cipherHashInfo.info3DESHMAC.cipherKey0,
|
|
XLR_SEC_3DES_KEY_LENGTH);
|
|
print_buf("HMAC Key",
|
|
&desc->ctl_desc.cipherHashInfo.info3DESHMAC.hmacKey0,
|
|
sizeof(HMAC_t));
|
|
break;
|
|
case XLR_SEC_VECTOR__CIPHER_3DES__MODE_ECB_CBC:
|
|
DPRINT("VECTOR: XLR_SEC_VECTOR__CIPHER_3DES__MODE_ECB_CBC \n");
|
|
print_buf("CIPHER Key",
|
|
&desc->ctl_desc.cipherHashInfo.info3DES.cipherKey0,
|
|
XLR_SEC_3DES_KEY_LENGTH);
|
|
break;
|
|
case XLR_SEC_VECTOR__CIPHER_AES128__HMAC__MODE_CTR_CFB:
|
|
DPRINT("VECTOR: XLR_SEC_VECTOR__CIPHER_AES128__HMAC__MODE_CTR_CFB \n");
|
|
print_buf("CIPHER Key",
|
|
&desc->ctl_desc.cipherHashInfo.infoAES128HMAC.cipherKey0,
|
|
XLR_SEC_AES128_KEY_LENGTH);
|
|
print_buf("HMAC Key",
|
|
&desc->ctl_desc.cipherHashInfo.infoAES128HMAC.hmacKey0,
|
|
sizeof(HMAC_t));
|
|
break;
|
|
case XLR_SEC_VECTOR__CIPHER_AES128__MODE_CTR_CFB:
|
|
DPRINT("VECTOR: XLR_SEC_VECTOR__CIPHER_AES128__MODE_CTR_CFB \n");
|
|
print_buf("CIPHER Key",
|
|
&desc->ctl_desc.cipherHashInfo.infoAES128.cipherKey0,
|
|
XLR_SEC_AES128_KEY_LENGTH);
|
|
break;
|
|
case XLR_SEC_VECTOR__CIPHER_AES128__HMAC__MODE_ECB_CBC_OFB:
|
|
DPRINT("VECTOR: XLR_SEC_VECTOR__CIPHER_AES128__HMAC__MODE_ECB_CBC_OFB\n");
|
|
print_buf("CIPHER Key",
|
|
&desc->ctl_desc.cipherHashInfo.infoAES128HMAC.cipherKey0,
|
|
XLR_SEC_AES128_KEY_LENGTH);
|
|
print_buf("HMAC Key",
|
|
&desc->ctl_desc.cipherHashInfo.infoAES128HMAC.hmacKey0,
|
|
sizeof(HMAC_t));
|
|
break;
|
|
case XLR_SEC_VECTOR__CIPHER_AES128__MODE_ECB_CBC_OFB:
|
|
DPRINT("VECTOR: XLR_SEC_VECTOR__CIPHER_AES128__MODE_ECB_CBC_OFB \n");
|
|
print_buf("CIPHER Key",
|
|
&desc->ctl_desc.cipherHashInfo.infoAES128.cipherKey0,
|
|
XLR_SEC_AES128_KEY_LENGTH);
|
|
break;
|
|
case XLR_SEC_VECTOR__CIPHER_AES192__HMAC__MODE_CTR_CFB:
|
|
DPRINT("VECTOR: XLR_SEC_VECTOR__CIPHER_AES192__HMAC__MODE_CTR_CFB \n");
|
|
print_buf("CIPHER Key",
|
|
&desc->ctl_desc.cipherHashInfo.infoAES192HMAC.cipherKey0,
|
|
XLR_SEC_AES192_KEY_LENGTH);
|
|
print_buf("HMAC Key",
|
|
&desc->ctl_desc.cipherHashInfo.infoAES192HMAC.hmacKey0,
|
|
sizeof(HMAC_t));
|
|
break;
|
|
case XLR_SEC_VECTOR__CIPHER_AES192__MODE_CTR_CFB:
|
|
DPRINT("VECTOR: XLR_SEC_VECTOR__CIPHER_AES192__MODE_CTR_CFB \n");
|
|
print_buf("CIPHER Key",
|
|
&desc->ctl_desc.cipherHashInfo.infoAES192.cipherKey0,
|
|
XLR_SEC_AES192_KEY_LENGTH);
|
|
break;
|
|
case XLR_SEC_VECTOR__CIPHER_AES192__HMAC__MODE_ECB_CBC_OFB:
|
|
DPRINT("VECTOR: XLR_SEC_VECTOR__CIPHER_AES192__HMAC__MODE_ECB_CBC_OFB\n");
|
|
print_buf("CIPHER Key",
|
|
&desc->ctl_desc.cipherHashInfo.infoAES192HMAC.cipherKey0,
|
|
XLR_SEC_AES192_KEY_LENGTH);
|
|
print_buf("HMAC Key",
|
|
&desc->ctl_desc.cipherHashInfo.infoAES192HMAC.hmacKey0,
|
|
sizeof(HMAC_t));
|
|
break;
|
|
case XLR_SEC_VECTOR__CIPHER_AES192__MODE_ECB_CBC_OFB:
|
|
DPRINT("VECTOR: XLR_SEC_VECTOR__CIPHER_AES192__MODE_ECB_CBC_OFB \n");
|
|
print_buf("CIPHER Key",
|
|
&desc->ctl_desc.cipherHashInfo.infoAES192.cipherKey0,
|
|
XLR_SEC_AES192_KEY_LENGTH);
|
|
break;
|
|
|
|
case XLR_SEC_VECTOR__CIPHER_AES256__HMAC__MODE_CTR_CFB:
|
|
DPRINT("VECTOR: XLR_SEC_VECTOR__CIPHER_AES256__HMAC__MODE_CTR_CFB \n");
|
|
print_buf("CIPHER Key",
|
|
&desc->ctl_desc.cipherHashInfo.infoAES256HMAC.cipherKey0,
|
|
XLR_SEC_AES256_KEY_LENGTH);
|
|
print_buf("HMAC Key",
|
|
&desc->ctl_desc.cipherHashInfo.infoAES256HMAC.hmacKey0,
|
|
sizeof(HMAC_t));
|
|
break;
|
|
case XLR_SEC_VECTOR__CIPHER_AES256__MODE_CTR_CFB:
|
|
DPRINT("VECTOR: XLR_SEC_VECTOR__CIPHER_AES256__MODE_CTR_CFB \n");
|
|
print_buf("CIPHER Key",
|
|
&desc->ctl_desc.cipherHashInfo.infoAES256.cipherKey0,
|
|
XLR_SEC_AES256_KEY_LENGTH);
|
|
break;
|
|
case XLR_SEC_VECTOR__CIPHER_AES256__HMAC__MODE_ECB_CBC_OFB:
|
|
DPRINT("VECTOR: XLR_SEC_VECTOR__CIPHER_AES256__HMAC__MODE_ECB_CBC_OFB \n");
|
|
print_buf("CIPHER Key",
|
|
&desc->ctl_desc.cipherHashInfo.infoAES256HMAC.cipherKey0,
|
|
XLR_SEC_AES256_KEY_LENGTH);
|
|
print_buf("HMAC Key",
|
|
&desc->ctl_desc.cipherHashInfo.infoAES256HMAC.hmacKey0,
|
|
sizeof(HMAC_t));
|
|
break;
|
|
case XLR_SEC_VECTOR__CIPHER_AES256__MODE_ECB_CBC_OFB:
|
|
DPRINT("VECTOR: XLR_SEC_VECTOR__CIPHER_AES256__MODE_ECB_CBC_OFB \n");
|
|
print_buf("CIPHER Key",
|
|
&desc->ctl_desc.cipherHashInfo.infoAES256.cipherKey0,
|
|
XLR_SEC_AES256_KEY_LENGTH);
|
|
break;
|
|
case XLR_SEC_VECTOR_CIPHER_ARC4__HMAC2:
|
|
DPRINT("VECTOR: XLR_SEC_VECTOR_CIPHER_ARC4__HMAC2 \n");
|
|
print_buf("ARC4 Key",
|
|
&desc->ctl_desc.cipherHashInfo.infoARC4HMAC2.cipherKey0,
|
|
GET_FIELD(word, CTL_DSC_ARC4_KEYLEN));
|
|
print_buf("HMAC2 Key",
|
|
&desc->ctl_desc.cipherHashInfo.infoARC4HMAC2.hmacKey0,
|
|
sizeof(HMAC2_t));
|
|
break;
|
|
case XLR_SEC_VECTOR_CIPHER_ARC4__HMAC2__STATE:
|
|
DPRINT("VECTOR: XLR_SEC_VECTOR_CIPHER_ARC4__HMAC2__STATE \n");
|
|
print_buf("ARC4 Key",
|
|
&desc->ctl_desc.cipherHashInfo.infoARC4StateHMAC2.cipherKey0,
|
|
GET_FIELD(word, CTL_DSC_ARC4_KEYLEN));
|
|
print_buf("HMAC2 Key",
|
|
&desc->ctl_desc.cipherHashInfo.infoARC4StateHMAC2.hmacKey0,
|
|
sizeof(HMAC2_t));
|
|
break;
|
|
case XLR_SEC_VECTOR_HMAC2:
|
|
DPRINT("VECTOR: XLR_SEC_VECTOR_HMAC2 \n");
|
|
print_buf("HMAC2 Key",
|
|
&desc->ctl_desc.cipherHashInfo.infoHMAC2.hmacKey0,
|
|
sizeof(HMAC2_t));
|
|
break;
|
|
case XLR_SEC_VECTOR__CIPHER_DES__HMAC2__MODE_ECB_CBC:
|
|
DPRINT("VECTOR: XLR_SEC_VECTOR__CIPHER_DES__HMAC2__MODE_ECB_CBC \n");
|
|
print_buf("CIPHER Key",
|
|
&desc->ctl_desc.cipherHashInfo.infoDESHMAC2.cipherKey0,
|
|
XLR_SEC_DES_KEY_LENGTH);
|
|
print_buf("HMAC2 Key",
|
|
&desc->ctl_desc.cipherHashInfo.infoDESHMAC2.hmacKey0,
|
|
sizeof(HMAC2_t));
|
|
break;
|
|
case XLR_SEC_VECTOR__CIPHER_3DES__HMAC2__MODE_ECB_CBC:
|
|
DPRINT("VECTOR: XLR_SEC_VECTOR__CIPHER_3DES__HMAC2__MODE_ECB_CBC \n");
|
|
print_buf("CIPHER Key",
|
|
&desc->ctl_desc.cipherHashInfo.info3DESHMAC2.cipherKey0,
|
|
XLR_SEC_3DES_KEY_LENGTH);
|
|
print_buf("HMAC2 Key",
|
|
&desc->ctl_desc.cipherHashInfo.info3DESHMAC2.hmacKey0,
|
|
sizeof(HMAC2_t));
|
|
break;
|
|
case XLR_SEC_VECTOR__CIPHER_AES128__HMAC2__MODE_CTR_CFB:
|
|
DPRINT("VECTOR: XLR_SEC_VECTOR__CIPHER_AES128__HMAC2__MODE_CTR_CFB \n");
|
|
print_buf("CIPHER Key",
|
|
&desc->ctl_desc.cipherHashInfo.infoAES128HMAC2.cipherKey0,
|
|
XLR_SEC_AES128_KEY_LENGTH);
|
|
print_buf("HMAC2 Key",
|
|
&desc->ctl_desc.cipherHashInfo.infoAES128HMAC2.hmacKey0,
|
|
sizeof(HMAC2_t));
|
|
break;
|
|
case XLR_SEC_VECTOR__CIPHER_AES128__HMAC2__MODE_ECB_CBC_OFB:
|
|
DPRINT("VECTOR: XLR_SEC_VECTOR__CIPHER_AES128__HMAC2__MODE_ECB_CBC_OFB\n");
|
|
print_buf("CIPHER Key",
|
|
&desc->ctl_desc.cipherHashInfo.infoAES128HMAC2.cipherKey0,
|
|
XLR_SEC_AES128_KEY_LENGTH);
|
|
print_buf("HMAC2 Key",
|
|
&desc->ctl_desc.cipherHashInfo.infoAES128HMAC2.hmacKey0,
|
|
sizeof(HMAC2_t));
|
|
break;
|
|
case XLR_SEC_VECTOR__CIPHER_AES192__HMAC2__MODE_CTR_CFB:
|
|
DPRINT("VECTOR: XLR_SEC_VECTOR__CIPHER_AES192__HMAC2__MODE_CTR_CFB \n");
|
|
print_buf("CIPHER Key",
|
|
&desc->ctl_desc.cipherHashInfo.infoAES192HMAC2.cipherKey0,
|
|
XLR_SEC_AES192_KEY_LENGTH);
|
|
print_buf("HMAC2 Key",
|
|
&desc->ctl_desc.cipherHashInfo.infoAES192HMAC2.hmacKey0,
|
|
sizeof(HMAC2_t));
|
|
break;
|
|
case XLR_SEC_VECTOR__CIPHER_AES192__HMAC2__MODE_ECB_CBC_OFB:
|
|
DPRINT("VECTOR: XLR_SEC_VECTOR__CIPHER_AES192__HMAC2__MODE_ECB_CBC_OFB\n");
|
|
print_buf("CIPHER Key",
|
|
&desc->ctl_desc.cipherHashInfo.infoAES192HMAC2.cipherKey0,
|
|
XLR_SEC_AES192_KEY_LENGTH);
|
|
print_buf("HMAC2 Key",
|
|
&desc->ctl_desc.cipherHashInfo.infoAES192HMAC2.hmacKey0,
|
|
sizeof(HMAC2_t));
|
|
break;
|
|
case XLR_SEC_VECTOR__CIPHER_AES256__HMAC2__MODE_CTR_CFB:
|
|
DPRINT("VECTOR: XLR_SEC_VECTOR__CIPHER_AES256__HMAC2__MODE_CTR_CFB \n");
|
|
print_buf("CIPHER Key",
|
|
&desc->ctl_desc.cipherHashInfo.infoAES256HMAC2.cipherKey0,
|
|
XLR_SEC_AES256_KEY_LENGTH);
|
|
print_buf("HMAC2 Key",
|
|
&desc->ctl_desc.cipherHashInfo.infoAES256HMAC2.hmacKey0,
|
|
sizeof(HMAC2_t));
|
|
break;
|
|
|
|
case XLR_SEC_VECTOR__CIPHER_AES256__HMAC2__MODE_ECB_CBC_OFB:
|
|
DPRINT("VECTOR: XLR_SEC_VECTOR__CIPHER_AES256__HMAC2__MODE_ECB_CBC_OFB \n");
|
|
print_buf("CIPHER Key",
|
|
&desc->ctl_desc.cipherHashInfo.infoAES256HMAC2.cipherKey0,
|
|
XLR_SEC_AES256_KEY_LENGTH);
|
|
print_buf("HMAC2 Key",
|
|
&desc->ctl_desc.cipherHashInfo.infoAES256HMAC2.hmacKey0,
|
|
sizeof(HMAC2_t));
|
|
break;
|
|
case XLR_SEC_VECTOR_CIPHER_ARC4__GCM:
|
|
DPRINT("VECTOR: XLR_SEC_VECTOR_CIPHER_ARC4__GCM \n");
|
|
print_buf("ARC4 Key",
|
|
&desc->ctl_desc.cipherHashInfo.infoARC4GCM.cipherKey0,
|
|
GET_FIELD(word, CTL_DSC_ARC4_KEYLEN));
|
|
print_buf("GCM Key",
|
|
&desc->ctl_desc.cipherHashInfo.infoARC4GCM.GCMH0,
|
|
sizeof(GCM_t));
|
|
break;
|
|
case XLR_SEC_VECTOR_CIPHER_ARC4__GCM__STATE:
|
|
DPRINT("VECTOR: XLR_SEC_VECTOR_CIPHER_ARC4__GCM__STATE \n");
|
|
print_buf("ARC4 Key",
|
|
&desc->ctl_desc.cipherHashInfo.infoARC4StateGCM.cipherKey0,
|
|
GET_FIELD(word, CTL_DSC_ARC4_KEYLEN));
|
|
print_buf("GCM Key",
|
|
&desc->ctl_desc.cipherHashInfo.infoARC4StateGCM.GCMH0,
|
|
sizeof(GCM_t));
|
|
break;
|
|
case XLR_SEC_VECTOR_GCM:
|
|
DPRINT("VECTOR: XLR_SEC_VECTOR_GCM \n");
|
|
print_buf("GCM Key",
|
|
&desc->ctl_desc.cipherHashInfo.infoGCM.GCMH0,
|
|
sizeof(GCM_t));
|
|
break;
|
|
case XLR_SEC_VECTOR__CIPHER_DES__GCM__MODE_ECB_CBC:
|
|
DPRINT("VECTOR: XLR_SEC_VECTOR__CIPHER_DES__GCM__MODE_ECB_CBC \n");
|
|
print_buf("CIPHER Key",
|
|
&desc->ctl_desc.cipherHashInfo.infoDESGCM.cipherKey0,
|
|
XLR_SEC_DES_KEY_LENGTH);
|
|
print_buf("GCM Key",
|
|
&desc->ctl_desc.cipherHashInfo.infoDESGCM.GCMH0,
|
|
sizeof(GCM_t));
|
|
break;
|
|
case XLR_SEC_VECTOR__CIPHER_3DES__GCM__MODE_ECB_CBC:
|
|
DPRINT("VECTOR: XLR_SEC_VECTOR__CIPHER_3DES__GCM__MODE_ECB_CBC \n");
|
|
print_buf("CIPHER Key",
|
|
&desc->ctl_desc.cipherHashInfo.info3DESGCM.cipherKey0,
|
|
XLR_SEC_3DES_KEY_LENGTH);
|
|
print_buf("GCM Key",
|
|
&desc->ctl_desc.cipherHashInfo.info3DESGCM.GCMH0,
|
|
sizeof(GCM_t));
|
|
break;
|
|
case XLR_SEC_VECTOR__CIPHER_AES128__GCM__MODE_CTR_CFB:
|
|
DPRINT("VECTOR: XLR_SEC_VECTOR__CIPHER_AES128__GCM__MODE_CTR_CFB \n");
|
|
print_buf("CIPHER Key",
|
|
&desc->ctl_desc.cipherHashInfo.infoAES128GCM.cipherKey0,
|
|
XLR_SEC_AES128_KEY_LENGTH);
|
|
print_buf("GCM Key",
|
|
&desc->ctl_desc.cipherHashInfo.infoAES128GCM.GCMH0,
|
|
XLR_SEC_AES128_KEY_LENGTH);
|
|
break;
|
|
case XLR_SEC_VECTOR__CIPHER_AES128__GCM__MODE_ECB_CBC_OFB:
|
|
DPRINT("VECTOR: XLR_SEC_VECTOR__CIPHER_AES128__GCM__MODE_ECB_CBC_OFB\n");
|
|
print_buf("CIPHER Key",
|
|
&desc->ctl_desc.cipherHashInfo.infoAES128GCM.cipherKey0,
|
|
XLR_SEC_AES128_KEY_LENGTH);
|
|
print_buf("GCM Key",
|
|
&desc->ctl_desc.cipherHashInfo.infoAES128GCM.GCMH0,
|
|
XLR_SEC_AES128_KEY_LENGTH);
|
|
break;
|
|
case XLR_SEC_VECTOR__CIPHER_AES192__GCM__MODE_CTR_CFB:
|
|
DPRINT("VECTOR: XLR_SEC_VECTOR__CIPHER_AES192__GCM__MODE_CTR_CFB \n");
|
|
print_buf("CIPHER Key",
|
|
&desc->ctl_desc.cipherHashInfo.infoAES192GCM.cipherKey0,
|
|
XLR_SEC_AES192_KEY_LENGTH);
|
|
print_buf("GCM Key",
|
|
&desc->ctl_desc.cipherHashInfo.infoAES192GCM.GCMH0,
|
|
XLR_SEC_AES192_KEY_LENGTH);
|
|
break;
|
|
case XLR_SEC_VECTOR__CIPHER_AES192__GCM__MODE_ECB_CBC_OFB:
|
|
DPRINT("VECTOR: XLR_SEC_VECTOR__CIPHER_AES192__GCM__MODE_ECB_CBC_OFB\n");
|
|
print_buf("CIPHER Key",
|
|
&desc->ctl_desc.cipherHashInfo.infoAES192GCM.cipherKey0,
|
|
XLR_SEC_AES192_KEY_LENGTH);
|
|
print_buf("GCM Key",
|
|
&desc->ctl_desc.cipherHashInfo.infoAES192GCM.GCMH0,
|
|
XLR_SEC_AES192_KEY_LENGTH);
|
|
break;
|
|
case XLR_SEC_VECTOR__CIPHER_AES256__GCM__MODE_CTR_CFB:
|
|
DPRINT("VECTOR: XLR_SEC_VECTOR__CIPHER_AES256__GCM__MODE_CTR_CFB \n");
|
|
print_buf("CIPHER Key",
|
|
&desc->ctl_desc.cipherHashInfo.infoAES256GCM.cipherKey0,
|
|
XLR_SEC_AES256_KEY_LENGTH);
|
|
print_buf("GCM Key",
|
|
&desc->ctl_desc.cipherHashInfo.infoAES256GCM.GCMH0,
|
|
XLR_SEC_AES256_KEY_LENGTH);
|
|
break;
|
|
case XLR_SEC_VECTOR__CIPHER_AES256__GCM__MODE_ECB_CBC_OFB:
|
|
DPRINT("VECTOR: XLR_SEC_VECTOR__CIPHER_AES256__GCM__MODE_ECB_CBC_OFB \n");
|
|
print_buf("CIPHER Key",
|
|
&desc->ctl_desc.cipherHashInfo.infoAES256GCM.cipherKey0,
|
|
XLR_SEC_AES256_KEY_LENGTH);
|
|
print_buf("GCM Key",
|
|
&desc->ctl_desc.cipherHashInfo.infoAES256GCM.GCMH0,
|
|
XLR_SEC_AES256_KEY_LENGTH);
|
|
break;
|
|
case XLR_SEC_VECTOR_CIPHER_ARC4__F9:
|
|
DPRINT("VECTOR: XLR_SEC_VECTOR_CIPHER_ARC4__F9 \n");
|
|
print_buf("ARC4 Key",
|
|
&desc->ctl_desc.cipherHashInfo.infoARC4F9.cipherKey0,
|
|
GET_FIELD(word, CTL_DSC_ARC4_KEYLEN));
|
|
print_buf("F9 Key",
|
|
&desc->ctl_desc.cipherHashInfo.infoARC4F9.authKey0,
|
|
sizeof(F9_t));
|
|
break;
|
|
case XLR_SEC_VECTOR_CIPHER_ARC4__F9__STATE:
|
|
DPRINT("VECTOR: XLR_SEC_VECTOR_CIPHER_ARC4__F9__STATE \n");
|
|
print_buf("ARC4 Key",
|
|
&desc->ctl_desc.cipherHashInfo.infoARC4StateF9.cipherKey0,
|
|
GET_FIELD(word, CTL_DSC_ARC4_KEYLEN));
|
|
print_buf("F9 Key",
|
|
&desc->ctl_desc.cipherHashInfo.infoARC4StateF9.authKey0,
|
|
sizeof(F9_t));
|
|
break;
|
|
case XLR_SEC_VECTOR_F9:
|
|
DPRINT("VECTOR: XLR_SEC_VECTOR_F9 \n");
|
|
print_buf("F9 Key",
|
|
&desc->ctl_desc.cipherHashInfo.infoF9.authKey0,
|
|
sizeof(F9_t));
|
|
break;
|
|
case XLR_SEC_VECTOR__CIPHER_DES__F9__MODE_ECB_CBC:
|
|
DPRINT("VECTOR: XLR_SEC_VECTOR__CIPHER_DES__F9__MODE_ECB_CBC \n");
|
|
print_buf("CIPHER Key",
|
|
&desc->ctl_desc.cipherHashInfo.infoDESF9.cipherKey0,
|
|
XLR_SEC_DES_KEY_LENGTH);
|
|
print_buf("F9 Key",
|
|
&desc->ctl_desc.cipherHashInfo.infoDESF9.authKey0,
|
|
sizeof(F9_t));
|
|
break;
|
|
case XLR_SEC_VECTOR__CIPHER_3DES__F9__MODE_ECB_CBC:
|
|
DPRINT("VECTOR: XLR_SEC_VECTOR__CIPHER_3DES__F9__MODE_ECB_CBC \n");
|
|
print_buf("CIPHER Key",
|
|
&desc->ctl_desc.cipherHashInfo.info3DESF9.cipherKey0,
|
|
XLR_SEC_3DES_KEY_LENGTH);
|
|
print_buf("F9 Key",
|
|
&desc->ctl_desc.cipherHashInfo.info3DESF9.authKey0,
|
|
sizeof(F9_t));
|
|
break;
|
|
case XLR_SEC_VECTOR__CIPHER_AES128__F9__MODE_CTR_CFB:
|
|
DPRINT("VECTOR: XLR_SEC_VECTOR__CIPHER_AES128__F9__MODE_CTR_CFB \n");
|
|
print_buf("CIPHER Key",
|
|
&desc->ctl_desc.cipherHashInfo.infoAES128F9.cipherKey0,
|
|
XLR_SEC_AES128_KEY_LENGTH);
|
|
print_buf("F9 Key",
|
|
&desc->ctl_desc.cipherHashInfo.infoAES128F9.authKey0,
|
|
sizeof(F9_t));
|
|
break;
|
|
case XLR_SEC_VECTOR__CIPHER_AES128__F9__MODE_ECB_CBC_OFB:
|
|
DPRINT("VECTOR: XLR_SEC_VECTOR__CIPHER_AES128__F9__MODE_ECB_CBC_OFB\n");
|
|
print_buf("CIPHER Key",
|
|
&desc->ctl_desc.cipherHashInfo.infoAES128F9.cipherKey0,
|
|
XLR_SEC_AES128_KEY_LENGTH);
|
|
print_buf("F9 Key",
|
|
&desc->ctl_desc.cipherHashInfo.infoAES128F9.authKey0,
|
|
sizeof(F9_t));
|
|
break;
|
|
case XLR_SEC_VECTOR__CIPHER_AES192__F9__MODE_CTR_CFB:
|
|
DPRINT("VECTOR: XLR_SEC_VECTOR__CIPHER_AES192__F9__MODE_CTR_CFB \n");
|
|
print_buf("CIPHER Key",
|
|
&desc->ctl_desc.cipherHashInfo.infoAES192F9.cipherKey0,
|
|
XLR_SEC_AES192_KEY_LENGTH);
|
|
print_buf("F9 Key",
|
|
&desc->ctl_desc.cipherHashInfo.infoAES192F9.authKey0,
|
|
sizeof(F9_t));
|
|
break;
|
|
case XLR_SEC_VECTOR__CIPHER_AES192__F9__MODE_ECB_CBC_OFB:
|
|
DPRINT("VECTOR: XLR_SEC_VECTOR__CIPHER_AES192__F9__MODE_ECB_CBC_OFB\n");
|
|
print_buf("CIPHER Key",
|
|
&desc->ctl_desc.cipherHashInfo.infoAES192F9.cipherKey0,
|
|
XLR_SEC_AES192_KEY_LENGTH);
|
|
print_buf("F9 Key",
|
|
&desc->ctl_desc.cipherHashInfo.infoAES192F9.authKey0,
|
|
sizeof(F9_t));
|
|
break;
|
|
case XLR_SEC_VECTOR__CIPHER_AES256__F9__MODE_CTR_CFB:
|
|
DPRINT("VECTOR: XLR_SEC_VECTOR__CIPHER_AES256__F9__MODE_CTR_CFB \n");
|
|
print_buf("CIPHER Key",
|
|
&desc->ctl_desc.cipherHashInfo.infoAES256F9.cipherKey0,
|
|
XLR_SEC_AES256_KEY_LENGTH);
|
|
print_buf("F9 Key",
|
|
&desc->ctl_desc.cipherHashInfo.infoAES256F9.authKey0,
|
|
sizeof(F9_t));
|
|
break;
|
|
case XLR_SEC_VECTOR__CIPHER_AES256__F9__MODE_ECB_CBC_OFB:
|
|
DPRINT("VECTOR: XLR_SEC_VECTOR__CIPHER_AES256__F9__MODE_ECB_CBC_OFB \n");
|
|
print_buf("CIPHER Key",
|
|
&desc->ctl_desc.cipherHashInfo.infoAES256F9.cipherKey0,
|
|
XLR_SEC_AES256_KEY_LENGTH);
|
|
print_buf("F9 Key",
|
|
&desc->ctl_desc.cipherHashInfo.infoAES256F9.authKey0,
|
|
sizeof(F9_t));
|
|
break;
|
|
case XLR_SEC_VECTOR__CIPHER_AES128__HMAC__MODE_F8:
|
|
DPRINT("VECTOR: XLR_SEC_VECTOR__CIPHER_AES128__HMAC__MODE_F8 \n");
|
|
print_buf("CIPHER Key",
|
|
&desc->ctl_desc.cipherHashInfo.infoAES128F8HMAC.cipherKey0,
|
|
XLR_SEC_AES128F8_KEY_LENGTH);
|
|
print_buf("HMAC Key",
|
|
&desc->ctl_desc.cipherHashInfo.infoAES128F8HMAC.hmacKey0,
|
|
sizeof(HMAC_t));
|
|
break;
|
|
case XLR_SEC_VECTOR__CIPHER_AES128__MODE_F8:
|
|
DPRINT("VECTOR: XLR_SEC_VECTOR__CIPHER_AES128__MODE_F8 \n");
|
|
print_buf("CIPHER Key",
|
|
&desc->ctl_desc.cipherHashInfo.infoAES128F8.cipherKey0,
|
|
XLR_SEC_AES128F8_KEY_LENGTH);
|
|
break;
|
|
case XLR_SEC_VECTOR__CIPHER_AES192__HMAC__MODE_F8:
|
|
DPRINT("VECTOR: XLR_SEC_VECTOR__CIPHER_AES192__HMAC__MODE_F8 \n");
|
|
print_buf("CIPHER Key",
|
|
&desc->ctl_desc.cipherHashInfo.infoAES192F8HMAC.cipherKey0,
|
|
XLR_SEC_AES192F8_KEY_LENGTH);
|
|
print_buf("HMAC Key",
|
|
&desc->ctl_desc.cipherHashInfo.infoAES192F8HMAC.hmacKey0,
|
|
sizeof(HMAC_t));
|
|
break;
|
|
case XLR_SEC_VECTOR__CIPHER_AES192__MODE_F8:
|
|
DPRINT("VECTOR: XLR_SEC_VECTOR__CIPHER_AES192__MODE_F8 \n");
|
|
print_buf("CIPHER Key",
|
|
&desc->ctl_desc.cipherHashInfo.infoAES192F8.cipherKey0,
|
|
XLR_SEC_AES192F8_KEY_LENGTH);
|
|
break;
|
|
case XLR_SEC_VECTOR__CIPHER_AES256__HMAC__MODE_F8:
|
|
DPRINT("VECTOR: XLR_SEC_VECTOR__CIPHER_AES256__HMAC__MODE_F8 \n");
|
|
print_buf("CIPHER Key",
|
|
&desc->ctl_desc.cipherHashInfo.infoAES256F8HMAC.cipherKey0,
|
|
XLR_SEC_AES256F8_KEY_LENGTH);
|
|
print_buf("HMAC Key",
|
|
&desc->ctl_desc.cipherHashInfo.infoAES256HMAC.hmacKey0,
|
|
sizeof(HMAC_t));
|
|
break;
|
|
case XLR_SEC_VECTOR__CIPHER_AES256__MODE_F8:
|
|
DPRINT("VECTOR: XLR_SEC_VECTOR__CIPHER_AES256__MODE_F8 \n");
|
|
print_buf("CIPHER Key",
|
|
&desc->ctl_desc.cipherHashInfo.infoAES256F8.cipherKey0,
|
|
XLR_SEC_AES256F8_KEY_LENGTH);
|
|
break;
|
|
case XLR_SEC_VECTOR__CIPHER_AES128__HMAC2__MODE_F8:
|
|
DPRINT("VECTOR: XLR_SEC_VECTOR__CIPHER_AES128__HMAC2__MODE_F8 \n");
|
|
print_buf("CIPHER Key",
|
|
&desc->ctl_desc.cipherHashInfo.infoAES128F8HMAC2.cipherKey0,
|
|
XLR_SEC_AES128F8_KEY_LENGTH);
|
|
print_buf("HMAC2 Key",
|
|
&desc->ctl_desc.cipherHashInfo.infoAES128F8HMAC2.hmacKey0,
|
|
sizeof(HMAC2_t));
|
|
break;
|
|
case XLR_SEC_VECTOR__CIPHER_AES192__HMAC2__MODE_F8:
|
|
DPRINT("VECTOR: XLR_SEC_VECTOR__CIPHER_AES192__HMAC2__MODE_F8 \n");
|
|
print_buf("CIPHER Key",
|
|
&desc->ctl_desc.cipherHashInfo.infoAES192F8HMAC2.cipherKey0,
|
|
XLR_SEC_AES192F8_KEY_LENGTH);
|
|
print_buf("HMAC2 Key",
|
|
&desc->ctl_desc.cipherHashInfo.infoAES192F8HMAC2.hmacKey0,
|
|
sizeof(HMAC2_t));
|
|
break;
|
|
case XLR_SEC_VECTOR__CIPHER_AES256__HMAC2__MODE_F8:
|
|
DPRINT("VECTOR: XLR_SEC_VECTOR__CIPHER_AES256__HMAC2__MODE_F8 \n");
|
|
print_buf("CIPHER Key",
|
|
&desc->ctl_desc.cipherHashInfo.infoAES256F8HMAC2.cipherKey0,
|
|
XLR_SEC_AES256F8_KEY_LENGTH);
|
|
print_buf("HMAC2 Key",
|
|
&desc->ctl_desc.cipherHashInfo.infoAES256F8HMAC2.hmacKey0,
|
|
sizeof(HMAC2_t));
|
|
break;
|
|
case XLR_SEC_VECTOR__CIPHER_AES128__GCM__MODE_F8:
|
|
DPRINT("VECTOR: XLR_SEC_VECTOR__CIPHER_AES128__GCM__MODE_F8 \n");
|
|
print_buf("CIPHER Key",
|
|
&desc->ctl_desc.cipherHashInfo.infoAES128F8GCM.cipherKey0,
|
|
XLR_SEC_AES128F8_KEY_LENGTH);
|
|
print_buf("GCM Key",
|
|
&desc->ctl_desc.cipherHashInfo.infoAES128GCM.GCMH0,
|
|
XLR_SEC_AES128_KEY_LENGTH);
|
|
break;
|
|
case XLR_SEC_VECTOR__CIPHER_AES192__GCM__MODE_F8:
|
|
DPRINT("VECTOR: XLR_SEC_VECTOR__CIPHER_AES192__GCM__MODE_F8 \n");
|
|
print_buf("CIPHER Key",
|
|
&desc->ctl_desc.cipherHashInfo.infoAES192F8GCM.cipherKey0,
|
|
XLR_SEC_AES192_KEY_LENGTH);
|
|
print_buf("GCM Key",
|
|
&desc->ctl_desc.cipherHashInfo.infoAES192F8GCM.GCMH0,
|
|
XLR_SEC_AES192_KEY_LENGTH);
|
|
break;
|
|
case XLR_SEC_VECTOR__CIPHER_AES256__GCM__MODE_F8:
|
|
DPRINT("VECTOR: XLR_SEC_VECTOR__CIPHER_AES256__GCM__MODE_F8 \n");
|
|
print_buf("CIPHER Key",
|
|
&desc->ctl_desc.cipherHashInfo.infoAES256F8GCM.cipherKey0,
|
|
XLR_SEC_AES256F8_KEY_LENGTH);
|
|
print_buf("GCM Key",
|
|
&desc->ctl_desc.cipherHashInfo.infoAES256F8GCM.GCMH0,
|
|
XLR_SEC_AES256_KEY_LENGTH);
|
|
break;
|
|
case XLR_SEC_VECTOR__CIPHER_AES128__F9__MODE_F8:
|
|
DPRINT("VECTOR: XLR_SEC_VECTOR__CIPHER_AES128__F9__MODE_F8 \n");
|
|
print_buf("CIPHER Key",
|
|
&desc->ctl_desc.cipherHashInfo.infoAES128F8F9.cipherKey0,
|
|
XLR_SEC_AES128F8_KEY_LENGTH);
|
|
print_buf("F9 Key",
|
|
&desc->ctl_desc.cipherHashInfo.infoAES128F8F9.authKey0,
|
|
sizeof(F9_t));
|
|
break;
|
|
case XLR_SEC_VECTOR__CIPHER_AES192__F9__MODE_F8:
|
|
DPRINT("VECTOR: XLR_SEC_VECTOR__CIPHER_AES192__F9__MODE_F8 \n");
|
|
print_buf("CIPHER Key",
|
|
&desc->ctl_desc.cipherHashInfo.infoAES192F8F9.cipherKey0,
|
|
XLR_SEC_AES192F8_KEY_LENGTH);
|
|
print_buf("F9 Key",
|
|
&desc->ctl_desc.cipherHashInfo.infoAES192F8F9.authKey0,
|
|
sizeof(F9_t));
|
|
break;
|
|
case XLR_SEC_VECTOR__CIPHER_AES256__F9__MODE_F8:
|
|
DPRINT("VECTOR: XLR_SEC_VECTOR__CIPHER_AES256__F9__MODE_F8 \n");
|
|
print_buf("CIPHER Key",
|
|
&desc->ctl_desc.cipherHashInfo.infoAES256F8F9.cipherKey0,
|
|
XLR_SEC_AES256F8_KEY_LENGTH);
|
|
print_buf("F9 Key",
|
|
&desc->ctl_desc.cipherHashInfo.infoAES256F8F9.authKey0,
|
|
sizeof(F9_t));
|
|
break;
|
|
|
|
default:
|
|
DPRINT("VECTOR: ???? \n");
|
|
DPRINT(">>> WHAT THE HECK !!! <<< \n");
|
|
break;
|
|
}
|
|
DPRINT("PACKET DESCRIPTOR: \n");
|
|
word = desc->pkt_desc.srcLengthIVOffUseIVNext;
|
|
DPRINT("\tSrcLengthIVOffsetIVNext: %llx\n", word);
|
|
DPRINT("\t\tLoad HMAC = %lld \n",
|
|
GET_FIELD(word, PKT_DSC_LOADHMACKEY));
|
|
DPRINT("\t\tPad Hash = %lld \n",
|
|
GET_FIELD(word, PKT_DSC_PADHASH));
|
|
DPRINT("\t\tHash Byte Count = %lld \n",
|
|
GET_FIELD(word, PKT_DSC_HASHBYTES));
|
|
DPRINT("\t\tNext = %lld \n",
|
|
GET_FIELD(word, PKT_DSC_NEXT));
|
|
DPRINT("\t\tUse IV = %lld \n",
|
|
GET_FIELD(word, PKT_DSC_IV));
|
|
DPRINT("\t\tIV Offset = %lld \n",
|
|
GET_FIELD(word, PKT_DSC_IVOFF));
|
|
DPRINT("\t\tPacket Length = %lld \n",
|
|
GET_FIELD(word, PKT_DSC_PKTLEN));
|
|
DPRINT("\t\tNLHMAC = %lld \n", GET_FIELD(word, PKT_DSC_NLHMAC));
|
|
DPRINT("\t\tBreak = %lld \n", GET_FIELD(word, PKT_DSC_BREAK));
|
|
DPRINT("\t\tWait = %lld \n", GET_FIELD(word, PKT_DSC_WAIT));
|
|
DPRINT("\t\tSegment Src Addr = %llx \n",
|
|
(GET_FIELD(word, PKT_DSC_SEGADDR) << 5) & 0xffffffffffULL);
|
|
DPRINT("\t\tSRTCP = %lld \n", GET_FIELD(word, PKT_DSC_SRTCP));
|
|
DPRINT("\t\tGlobal Src Offset = %lld \n",
|
|
GET_FIELD(word, PKT_DSC_SEGOFFSET));
|
|
|
|
word = desc->pkt_desc.dstDataSettings;
|
|
DPRINT("\tdstDataSettings: %llx \n", word);
|
|
DPRINT("\t\tArc4 Byte Count = %lld \n", GET_FIELD(word,
|
|
PKT_DSC_ARC4BYTECOUNT));
|
|
DPRINT("\t\tSym Operation = %lld \n", GET_FIELD(word, PKT_DSC_SYM_OP));
|
|
DPRINT("\t\tCipher Offset = %lld \n", GET_FIELD(word, PKT_DSC_CPHROFF));
|
|
DPRINT("\t\tHash Offset = %lld \n", GET_FIELD(word, PKT_DSC_HASHOFF));
|
|
DPRINT("\t\tHash Source = %lld \n", GET_FIELD(word, PKT_DSC_HASHSRC));
|
|
DPRINT("\t\tChecksum Offset = %lld \n", GET_FIELD(word,
|
|
PKT_DSC_CKSUMOFF));
|
|
DPRINT("\t\tChecksum Source = %lld \n", GET_FIELD(word,
|
|
PKT_DSC_CKSUMSRC));
|
|
DPRINT("\t\tCipher Dest Addr = %llx \n", GET_FIELD(word,
|
|
PKT_DSC_CPHR_DST_ADDR));
|
|
DPRINT("\t\tCipher Dest Dword = %lld \n", GET_FIELD(word,
|
|
PKT_DSC_CPHR_DST_DWOFFSET));
|
|
DPRINT("\t\tCipher Dest Offset= %lld \n", GET_FIELD(word,
|
|
PKT_DSC_CPHR_DST_OFFSET));
|
|
word = desc->pkt_desc.authDstNonceLow;
|
|
DPRINT("\tauthDstNonceLow: %llx \n", word);
|
|
DPRINT("\t\tNonce Low 24 = %lld \n", GET_FIELD(word,
|
|
PKT_DSC_NONCE_LOW));
|
|
DPRINT("\t\tauthDst = %llx \n", GET_FIELD(word,
|
|
PKT_DSC_AUTH_DST_ADDR));
|
|
DPRINT("\t\tCipher Offset High= %lld \n", GET_FIELD(word,
|
|
PKT_DSC_CIPH_OFF_HI));
|
|
word = desc->pkt_desc.ckSumDstNonceHiCFBMaskLLWMask;
|
|
DPRINT("\tckSumDstNonceHiCFBMaskLLWMask: %llx \n", word);
|
|
DPRINT("\t\tHash Byte off = %lld \n", GET_FIELD(word, PKT_DSC_HASH_BYTE_OFF));
|
|
DPRINT("\t\tPacket Len bytes = %lld \n", GET_FIELD(word, PKT_DSC_PKTLEN_BYTES));
|
|
DPRINT("\t\tLast Long Word Mask = %lld \n", GET_FIELD(word,
|
|
PKT_DSC_LASTWORD));
|
|
DPRINT("\t\tCipher Dst Address = %llx \n", GET_FIELD(word,
|
|
PKT_DSC_CPHR_DST_ADDR));
|
|
DPRINT("\t\tGlobal Dst Offset = %lld \n", GET_FIELD(word,
|
|
PKT_DSC_CPHR_DST_OFFSET));
|
|
|
|
DPRINT("CFG_VECTOR = %04x\n", cfg_vector);
|
|
DPRINT("\n\n");
|
|
}
|
|
|
|
#endif
|
|
|
|
|
|
|
|
/* This function is called from an interrupt handler */
|
|
void
|
|
xlr_sec_msgring_handler(int bucket, int size, int code, int stid,
|
|
struct msgrng_msg *msg, void *data)
|
|
{
|
|
uint64_t error;
|
|
uint64_t addr, sec_eng, sec_pipe;
|
|
xlr_sec_io_pt op = NULL;
|
|
symkey_desc_pt desc = NULL;
|
|
struct xlr_sec_session *ses = NULL;
|
|
struct xlr_sec_command *cmd = NULL;
|
|
|
|
|
|
if (code != MSGRNG_CODE_SEC) {
|
|
panic("xlr_sec_msgring_handler: bad code = %d,"
|
|
" expected code = %d\n",
|
|
code, MSGRNG_CODE_SEC);
|
|
}
|
|
if ((stid < MSGRNG_STNID_SEC0) || (stid > MSGRNG_STNID_PK0)) {
|
|
panic("xlr_sec_msgring_handler: bad stn id = %d, expect %d - %d\n",
|
|
stid, MSGRNG_STNID_SEC0, MSGRNG_STNID_PK0);
|
|
}
|
|
/*
|
|
* The Submit() operation encodes the engine and pipe in these two
|
|
* separate fields. This allows use to verify the result type with
|
|
* the submitted operation type.
|
|
*/
|
|
sec_eng = GET_FIELD(msg->msg0, MSG_CTL_OP_TYPE);
|
|
sec_pipe = GET_FIELD(msg->msg1, MSG_CTL_OP_TYPE);
|
|
|
|
|
|
error = msg->msg0 >> 40 & 0x1ff;
|
|
if (error)
|
|
printf("ctrl error = 0x%llx\n", error);
|
|
error = msg->msg1 >> 40 & 0x1ff;
|
|
if (error)
|
|
printf("data error = 0x%llx\n", error);
|
|
|
|
|
|
XLR_SEC_CMD_DIAG("[%s]: eng=%lld pipe=%lld\n",
|
|
__FUNCTION__, sec_eng, sec_pipe);
|
|
|
|
/* Symmetric Key Operation ? */
|
|
if (sec_eng == MSG0_CTL_OP_ENGINE_SYMKEY) {
|
|
|
|
/*
|
|
* The data descriptor address allows us to associate the
|
|
* response with the submitted operation. Address is 40-bit
|
|
* cacheline aligned address. We need to zero bit 0-4 since
|
|
* they are used for the engine and pipe Id.
|
|
*/
|
|
addr = GET_FIELD(msg->msg1, MSG_RSLT_DATA_DSC_ADDR);
|
|
|
|
addr = addr & ~((1 << 5) - 1);
|
|
if (!addr) {
|
|
panic("[%s:STNID_SEC]: NULL symkey addr!\n", __FUNCTION__);
|
|
|
|
}
|
|
/*
|
|
* The adddress points to the data descriptor. The operation
|
|
* descriptor is defined with the 32-byte cacheline size in
|
|
* mind. It allows the code to use this address to
|
|
* reference the symkey descriptor. (ref: xlr_sec_desc.h)
|
|
*/
|
|
addr = addr - sizeof(OperationDescriptor_t);
|
|
desc = (symkey_desc_pt) MIPS_PHYS_TO_KSEG0(addr);
|
|
|
|
if (!desc) {
|
|
printf("\nerror : not getting desc back correctly \n");
|
|
panic("[%s:STNID_SEC]: NULL symkey data descriptor!\n", __FUNCTION__);
|
|
}
|
|
ses = (struct xlr_sec_session *)desc->ses;
|
|
if (!ses) {
|
|
printf("\n error : not getting ses back correctly \n");
|
|
panic("[%s:STNID_SEC]: NULL symkey data descriptor!\n", __FUNCTION__);
|
|
}
|
|
cmd = &ses->cmd;
|
|
if (!cmd) {
|
|
printf("\n error : not getting cmd back correctly \n");
|
|
panic("[%s:STNID_SEC]: NULL symkey data descriptor!\n", __FUNCTION__);
|
|
}
|
|
op = &cmd->op;
|
|
if (!op) {
|
|
printf("\n error : not getting op back correctly \n");
|
|
panic("[%s:STNID_SEC]: NULL symkey data descriptor!\n", __FUNCTION__);
|
|
}
|
|
XLR_SEC_CMD_DIAG("[%s:STNID_SEC]: addr=0x%llx desc=%p alloc=%p \n",
|
|
__FUNCTION__, addr, desc, desc->alloc);
|
|
|
|
XLR_SEC_CMD_DIAG("[%s:STNID_SEC]: op_ctl=%p phys_self=%llx stn_id=%d \n",
|
|
__FUNCTION__, &desc->op_ctl, desc->op_ctl.phys_self,
|
|
desc->op_ctl.stn_id);
|
|
|
|
if (addr != desc->op_ctl.phys_self) {
|
|
XLR_SEC_CMD_DIAG("[%s:STNID_SEC]: Control Descriptor fails Self-Verify !\n",
|
|
__FUNCTION__);
|
|
printf("[%s:STNID_SEC]: Control Descriptor fails Self-Verify !\n",
|
|
__FUNCTION__);
|
|
printf("[%s:STNID_SEC]: addr=0x%llx desc=%p alloc=%p \n",
|
|
__FUNCTION__, (unsigned long long)addr, desc, desc->alloc);
|
|
printf("[%s:STNID_SEC]: op_ctl=%p phys_self=%llx stn_id=%d \n",
|
|
__FUNCTION__, &desc->op_ctl, (unsigned long long)desc->op_ctl.phys_self,
|
|
desc->op_ctl.stn_id);
|
|
|
|
}
|
|
if (desc->op_ctl.stn_id != MSGRNG_STNID_SEC0 &&
|
|
desc->op_ctl.stn_id != MSGRNG_STNID_SEC1) {
|
|
XLR_SEC_CMD_DIAG("[%s:STNID_SEC]: Operation Type Mismatch !\n",
|
|
__FUNCTION__);
|
|
printf("[%s:STNID_SEC]: Operation Type Mismatch !\n",
|
|
__FUNCTION__);
|
|
printf("[%s:STNID_SEC]: addr=0x%llx desc=%p alloc=%p \n",
|
|
__FUNCTION__, (unsigned long long)addr, desc, desc->alloc);
|
|
printf("[%s:STNID_SEC]: op_ctl=%p phys_self=%llx stn_id=%d \n",
|
|
__FUNCTION__, &desc->op_ctl, (unsigned long long)desc->op_ctl.phys_self,
|
|
desc->op_ctl.stn_id);
|
|
}
|
|
desc->ctl_result = GET_FIELD(msg->msg0, MSG_RSLT_CTL_INST_ERR);
|
|
desc->data_result = GET_FIELD(msg->msg1, MSG_RSLT_DATA_INST_ERR);
|
|
|
|
XLR_SEC_CMD_DIAG("[%s:STNID_SEC]: cpu=%d ctl_result=0x%llx data_result=%llx\n",
|
|
__FUNCTION__, desc->op_ctl.cpu,
|
|
desc->ctl_result, desc->data_result);
|
|
|
|
}
|
|
#if 0
|
|
else if (sec_eng == MSG0_CTL_OP_ENGINE_PUBKEY) {
|
|
pubkey_desc_pt desc;
|
|
|
|
if (sec_pipe != MSG1_CTL_OP_PUBKEY_PIPE0) {
|
|
/* response to uc load */
|
|
/*
|
|
* XLR_SEC_CMD_DIAG("[%s:STNID_SEC]: ecc cpu=%d
|
|
* ctl_result=0x%llx data_result=%llx\n",
|
|
* __FUNCTION__, desc->op_ctl.cpu, desc->ctl_result,
|
|
* desc->data_result);
|
|
*/
|
|
return;
|
|
}
|
|
/*
|
|
* The data descriptor address allows us to associate the
|
|
* response with the submitted operation. Address is 40-bit
|
|
* cacheline aligned address. We need to zero bit 0-4 since
|
|
* they are used for the engine and pipe Id.
|
|
*/
|
|
addr = GET_FIELD(msg->msg0, PUBKEY_RSLT_CTL_SRCADDR);
|
|
addr = addr & ~((1 << 5) - 1);
|
|
if (!addr) {
|
|
panic("[%s:STNID_SEC]: NULL pubkey ctrl desc!\n", __FUNCTION__);
|
|
}
|
|
/*
|
|
* The adddress points to the data descriptor. The operation
|
|
* descriptor is defined with the 32-byte cacheline size in
|
|
* mind. It allows the code to use this address to
|
|
* reference the symkey descriptor. (ref: xlr_sec_desc.h)
|
|
*/
|
|
addr = addr - sizeof(OperationDescriptor_t);
|
|
|
|
/* Get pointer to pubkey Descriptor */
|
|
desc = (pubkey_desc_pt) (unsigned long)addr;
|
|
if (!desc) {
|
|
panic("[%s:STNID_SEC]: NULL pubkey data descriptor!\n", __FUNCTION__);
|
|
}
|
|
XLR_SEC_CMD_DIAG("[%s:STNID_PK0]: addr=0x%llx desc=%p alloc=%p \n",
|
|
__FUNCTION__, addr, desc, desc->alloc);
|
|
|
|
XLR_SEC_CMD_DIAG("[%s:STNID_PK0]: op_ctl=%p phys_self=%llx stn_id=%d \n",
|
|
__FUNCTION__, &desc->op_ctl, desc->op_ctl.phys_self,
|
|
desc->op_ctl.stn_id);
|
|
|
|
if (addr != desc->op_ctl.phys_self) {
|
|
XLR_SEC_CMD_DIAG("[%s:STNID_PK0]: Control Descriptor fails Self-Verify !\n",
|
|
__FUNCTION__);
|
|
}
|
|
if (desc->op_ctl.stn_id != msgrng_stnid_pk0) {
|
|
XLR_SEC_CMD_DIAG("[%s:STNID_PK0]: Operation Type Mismatch ! \n",
|
|
__FUNCTION__);
|
|
}
|
|
desc->ctl_result = GET_FIELD(msg->msg0, PUBKEY_RSLT_CTL_ERROR);
|
|
desc->data_result = GET_FIELD(msg->msg1, PUBKEY_RSLT_DATA_ERROR);
|
|
|
|
XLR_SEC_CMD_DIAG("[%s:STNID_PK0]: ctl_result=0x%llx data_result=%llx\n",
|
|
__FUNCTION__, desc->ctl_result, desc->data_result);
|
|
|
|
}
|
|
#endif
|
|
else {
|
|
printf("[%s]: HANDLER bad id = %d\n", __FUNCTION__, stid);
|
|
}
|
|
#ifdef RMI_SEC_DEBUG
|
|
if (ses->multi_frag_flag) {
|
|
int i;
|
|
char *ptr;
|
|
|
|
printf("\n RETURNED DATA: \n");
|
|
|
|
ptr = (char *)(unsigned long)(desc->user.aligned_dest + cmd->op.cipher_offset);
|
|
for (i = 0; i < SEC_MAX_FRAG_LEN; i++) {
|
|
printf("%c ", (char)*ptr++);
|
|
if ((i % 10) == 0)
|
|
printf("\n");
|
|
}
|
|
|
|
printf("second desc\n");
|
|
ptr = (char *)(unsigned long)(desc->next_dest_buf);
|
|
for (i = 0; i < desc->next_src_len; i++) {
|
|
printf("%c ", (char)*ptr++);
|
|
if ((i % 10) == 0)
|
|
printf("\n");
|
|
}
|
|
}
|
|
#endif
|
|
|
|
|
|
/* Copy cipher-data to User-space */
|
|
if (op->cipher_type != XLR_SEC_CIPHER_TYPE_NONE) {
|
|
|
|
size = op->dest_buf_size;
|
|
|
|
/* DEBUG -dpk */
|
|
XLR_SEC_CMD_DIAG("cipher: to_addr=%p from_addr=%p size=%d \n",
|
|
desc->user.user_dest, desc->user.aligned_dest, size);
|
|
|
|
if (ses->multi_frag_flag) {
|
|
crypto_copyback(cmd->crp->crp_flags, cmd->crp->crp_buf, 0,
|
|
SEC_MAX_FRAG_LEN, (caddr_t)(long)desc->user.aligned_dest + op->cipher_offset);
|
|
crypto_copyback(cmd->crp->crp_flags, cmd->crp->crp_buf + SEC_MAX_FRAG_LEN, 0,
|
|
desc->next_src_len, (caddr_t)(long)desc->next_dest_buf);
|
|
crypto_done(cmd->crp);
|
|
} else {
|
|
crypto_copyback(cmd->crp->crp_flags, cmd->crp->crp_buf, 0,
|
|
cmd->op.dest_buf_size, (caddr_t)(long)desc->user.aligned_dest + op->cipher_offset);
|
|
crypto_done(cmd->crp);
|
|
|
|
}
|
|
|
|
|
|
}
|
|
/* Copy digest to User-space */
|
|
if (op->digest_type != XLR_SEC_DIGEST_TYPE_NONE) {
|
|
|
|
int offset = 0;
|
|
|
|
switch (op->digest_type) {
|
|
case XLR_SEC_DIGEST_TYPE_MD5:
|
|
size = XLR_SEC_MD5_LENGTH;
|
|
break;
|
|
case XLR_SEC_DIGEST_TYPE_SHA1:
|
|
size = XLR_SEC_SHA1_LENGTH;
|
|
break;
|
|
case XLR_SEC_DIGEST_TYPE_SHA256:
|
|
size = XLR_SEC_SHA256_LENGTH;
|
|
break;
|
|
case XLR_SEC_DIGEST_TYPE_SHA384:
|
|
size = XLR_SEC_SHA384_LENGTH;
|
|
break;
|
|
case XLR_SEC_DIGEST_TYPE_SHA512:
|
|
size = XLR_SEC_SHA512_LENGTH;
|
|
break;
|
|
case XLR_SEC_DIGEST_TYPE_GCM:
|
|
size = XLR_SEC_GCM_LENGTH;
|
|
break;
|
|
case XLR_SEC_DIGEST_TYPE_KASUMI_F9:
|
|
offset = 4;
|
|
size = XLR_SEC_KASUMI_F9_RESULT_LENGTH;
|
|
break;
|
|
default:
|
|
size = 0;
|
|
}
|
|
|
|
XLR_SEC_CMD_DIAG("digest: to_addr=%p from_addr=%p size=%d \n",
|
|
desc->user.user_auth, desc->user.aligned_auth, size);
|
|
memcpy(desc->user.user_auth, desc->user.aligned_auth + offset, size);
|
|
op->auth_dest = (uint64_t) (unsigned long)desc->user.user_auth;
|
|
}
|
|
if (op->cipher_type == XLR_SEC_CIPHER_TYPE_ARC4 &&
|
|
op->rc4_savestate) {
|
|
|
|
size = XLR_SEC_MAX_RC4_STATE_SIZE;
|
|
|
|
XLR_SEC_CMD_DIAG("state: to_addr=%p from_addr=%p size=%d \n",
|
|
desc->user.user_state, desc->user.aligned_state, size);
|
|
op->rc4_state = (uint64_t) (unsigned long)desc->user.user_state;
|
|
}
|
|
return;
|
|
}
|