/*- * 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 __FBSDID("$FreeBSD$"); #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include /* 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 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); static void xlr_sec_free_desc(symkey_desc_pt desc); void print_buf(char *desc, void *data, int len); xlr_sec_error_t xlr_sec_submit_op(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 *)(uintptr_t)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 *)(uintptr_t)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 = msgrng_access_enable(); code = message_send(SEC_MSGRING_WORDSIZE, MSGRNG_CODE_SEC, desc->op_ctl.stn_id, &send_msg); msgrng_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; aligned->op_ctl.vaddr = (uintptr_t)aligned; 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 = 0; //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 = 0; //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 = 0; //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 = 0; //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; uint32_t flags; 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); flags = xlr_enable_kx(); desc = (symkey_desc_pt)(uintptr_t)xlr_paddr_ld(addr + offsetof(OperationDescriptor_t, vaddr)); xlr_restore_kx(flags); 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; }