1/*- 2 * Copyright (c) 2003-2009 RMI Corporation 3 * All rights reserved. 4 * 5 * Redistribution and use in source and binary forms, with or without 6 * modification, are permitted provided that the following conditions 7 * are met: 8 * 1. Redistributions of source code must retain the above copyright 9 * notice, this list of conditions and the following disclaimer. 10 * 2. Redistributions in binary form must reproduce the above copyright 11 * notice, this list of conditions and the following disclaimer in the 12 * documentation and/or other materials provided with the distribution. 13 * 3. Neither the name of RMI Corporation, nor the names of its contributors, 14 * may be used to endorse or promote products derived from this software 15 * without specific prior written permission. 16 * 17 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND 18 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 19 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 20 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE 21 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 22 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 23 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 24 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 25 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 26 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 27 * SUCH DAMAGE. 28 * 29 * RMI_BSD 30 */ 31 32#include <sys/cdefs.h> 33__FBSDID("$FreeBSD$"); 34 35#include <sys/param.h> 36#include <sys/types.h> 37#include <sys/systm.h> 38#include <sys/kernel.h> 39#include <sys/module.h> 40#include <sys/malloc.h> 41#include <sys/bus.h> 42#include <machine/bus.h> 43#include <machine/md_var.h> 44#include <machine/cpuregs.h> 45 46#include <vm/vm.h> 47#include <vm/pmap.h> 48 49#include <opencrypto/cryptodev.h> 50 51#include <mips/rmi/rmi_mips_exts.h> 52#include <mips/rmi/iomap.h> 53#include <mips/rmi/pic.h> 54#include <mips/rmi/rmi_boot_info.h> 55#include <mips/rmi/msgring.h> 56#include <mips/rmi/board.h> 57#include <mips/rmi/dev/sec/rmilib.h> 58#include <mips/rmi/dev/sec/desc.h> 59 60 61/* static int msgrng_stnid_pk0 = MSGRNG_STNID_PK0; */ 62 63/* #define RMI_SEC_DEBUG */ 64 65#define SMP_CACHE_BYTES XLR_CACHELINE_SIZE 66#define NUM_CHUNKS(size, bits) ( ((size)>>(bits)) + (((size)&((1<<(bits))-1))?1:0) ) 67 68static const char nib2hex[] = "0123456789ABCDEF"; 69symkey_desc_pt g_desc; 70struct xlr_sec_command *g_cmd; 71 72#ifdef XLR_SEC_CMD_DEBUG 73static void decode_symkey_desc(symkey_desc_pt desc, uint32_t cfg_vector); 74#endif 75 76static int xlr_sec_cipher_hash_command(xlr_sec_io_pt op, symkey_desc_pt desc, 77 uint8_t); 78static xlr_sec_error_t xlr_sec_setup_descriptor(xlr_sec_io_pt op, 79 unsigned int flags, symkey_desc_pt desc, uint32_t * cfg_vector); 80 81static xlr_sec_error_t xlr_sec_setup_packet(xlr_sec_io_pt op, 82 symkey_desc_pt desc, unsigned int flags, uint64_t * data, 83 PacketDescriptor_pt pkt_desc, ControlDescriptor_pt ctl_desc, 84 uint32_t vector, PacketDescriptor_pt next_pkt_desc, 85 uint8_t multi_frag_flag); 86static int xlr_sec_submit_message(symkey_desc_pt desc, uint32_t cfg_vector); 87static xlr_sec_error_t xlr_sec_setup_cipher(xlr_sec_io_pt op, 88 ControlDescriptor_pt ctl_desc, uint32_t * vector); 89static xlr_sec_error_t xlr_sec_setup_digest(xlr_sec_io_pt op, 90 ControlDescriptor_pt ctl_desc, uint32_t * vector); 91static xlr_sec_error_t xlr_sec_setup_cksum(xlr_sec_io_pt op, 92 ControlDescriptor_pt ctl_desc); 93static xlr_sec_error_t xlr_sec_control_setup(xlr_sec_io_pt op, 94 unsigned int flags, uint64_t * control, ControlDescriptor_pt ctl_desc, 95 xlr_sec_drv_user_t * user, uint32_t vector); 96static void xlr_sec_free_desc(symkey_desc_pt desc); 97 98void print_buf(char *desc, void *data, int len); 99xlr_sec_error_t xlr_sec_submit_op(symkey_desc_pt desc); 100void xlr_sec_msgring_handler(int bucket, int size, int code, int stid, 101 struct msgrng_msg *msg, void *data); 102 103void 104xlr_sec_init(struct xlr_sec_softc *sc) 105{ 106 unsigned int i; 107 xlr_reg_t *mmio; 108 109 mmio = sc->mmio = xlr_io_mmio(XLR_IO_SECURITY_OFFSET); 110 xlr_write_reg(mmio, SEC_DMA_CREDIT, SEC_DMA_CREDIT_CONFIG); 111 xlr_write_reg(mmio, SEC_CONFIG2, SEC_CFG2_ROUND_ROBIN_ON); 112 113 for (i = 0; i < 8; i++) 114 xlr_write_reg(mmio, 115 SEC_MSG_BUCKET0_SIZE + i, 116 xlr_is_xls() ? 117 xls_bucket_sizes.bucket[MSGRNG_STNID_SEC + i] : 118 bucket_sizes.bucket[MSGRNG_STNID_SEC + i]); 119 120 for (i = 0; i < 128; i++) 121 xlr_write_reg(mmio, 122 SEC_CC_CPU0_0 + i, 123 xlr_is_xls() ? 124 xls_cc_table_sec.counters[i >> 3][i & 0x07] : 125 cc_table_sec.counters[i >> 3][i & 0x07]); 126 127 /* 128 * Register a bucket handler with the phoenix messaging subsystem 129 * For now, register handler for bucket 0->5 in msg stn 0 130 */ 131 if (register_msgring_handler(TX_STN_SAE, xlr_sec_msgring_handler, NULL)) { 132 panic("Couldn't register msgring handler 0\n"); 133 } 134 return; 135} 136 137int 138xlr_sec_setup(struct xlr_sec_session *ses, 139 struct xlr_sec_command *cmd, 140 symkey_desc_pt desc) 141{ 142 xlr_sec_io_pt op; 143 int size, ret_val; 144 int iv_len; 145 146 desc->ses = ses; 147 op = &cmd->op; 148 if (op == NULL) 149 return (-ENOMEM); 150 151 desc->ctl_desc.instruction = 0; 152 memset(&desc->ctl_desc.cipherHashInfo, 0, sizeof(CipherHashInfo_t)); 153 desc->control = 0; 154 desc->pkt_desc[0].srcLengthIVOffUseIVNext = 0; 155 desc->pkt_desc[0].dstDataSettings = 0; 156 desc->pkt_desc[0].authDstNonceLow = 0; 157 desc->pkt_desc[0].ckSumDstNonceHiCFBMaskLLWMask = 0; 158 desc->pkt_desc[1].srcLengthIVOffUseIVNext = 0; 159 desc->pkt_desc[1].dstDataSettings = 0; 160 desc->pkt_desc[1].authDstNonceLow = 0; 161 desc->pkt_desc[1].ckSumDstNonceHiCFBMaskLLWMask = 0; 162 desc->data = 0; 163 desc->ctl_result = 0; 164 desc->data_result = 0; 165 166 if (op->flags & XLR_SEC_FLAGS_HIGH_PRIORITY) 167 if (!xlr_is_xls()) 168 desc->op_ctl.stn_id++; 169 170 desc->user.user_src = (uint8_t *) (unsigned long)op->source_buf; 171 desc->user.user_dest = (uint8_t *) (unsigned long)op->dest_buf; 172 desc->user.user_auth = (uint8_t *) (unsigned long)op->auth_dest; 173 174 if ((op->cipher_type == XLR_SEC_CIPHER_TYPE_ARC4) && 175 (!op->rc4_state && (op->rc4_loadstate || op->rc4_savestate))) { 176 printf(" ** Load/Save State and no State **"); 177 xlr_sec_free_desc(desc); 178 return (-EINVAL); 179 } 180 desc->user.user_state = (uint8_t *) (unsigned long)op->rc4_state; 181 182 switch (op->cipher_type) { 183 case XLR_SEC_CIPHER_TYPE_NONE: 184 iv_len = 0; 185 break; 186 case XLR_SEC_CIPHER_TYPE_DES: 187 case XLR_SEC_CIPHER_TYPE_3DES: 188 iv_len = XLR_SEC_DES_IV_LENGTH; 189 break; 190 case XLR_SEC_CIPHER_TYPE_AES128: 191 case XLR_SEC_CIPHER_TYPE_AES192: 192 case XLR_SEC_CIPHER_TYPE_AES256: 193 iv_len = XLR_SEC_AES_IV_LENGTH; 194 break; 195 case XLR_SEC_CIPHER_TYPE_ARC4: 196 iv_len = XLR_SEC_ARC4_IV_LENGTH; 197 break; 198 case XLR_SEC_CIPHER_TYPE_KASUMI_F8: 199 iv_len = XLR_SEC_KASUMI_F8_IV_LENGTH; 200 break; 201 202 default: 203 printf(" ** Undefined Cipher Type **"); 204 xlr_sec_free_desc(desc); 205 return (-EINVAL); 206 } 207 size = op->source_buf_size + iv_len; 208 209 /* 210 * make sure that there are enough bytes for aes based stream 211 * ciphers 212 */ 213 if (op->cipher_mode == XLR_SEC_CIPHER_MODE_F8 || 214 op->cipher_mode == XLR_SEC_CIPHER_MODE_CTR) 215 size += XLR_SEC_AES_BLOCK_SIZE - 1; 216 217 if (op->cipher_type == XLR_SEC_CIPHER_TYPE_NONE) { 218 if (op->source_buf_size != 0) { 219 memcpy(desc->user.aligned_src, 220 (uint8_t *)(uintptr_t)op->source_buf, 221 op->source_buf_size); 222 } 223 } else { 224 if (ses->multi_frag_flag) { 225 /* copy IV into temporary kernel source buffer */ 226 memcpy(desc->user.aligned_src, &op->initial_vector[0], iv_len); 227 228 /* copy input data to temporary kernel source buffer */ 229 memcpy((uint8_t *) (desc->user.aligned_src + iv_len), 230 (uint8_t *) (unsigned long)op->source_buf, SEC_MAX_FRAG_LEN); 231 232 desc->next_src_len = op->source_buf_size - SEC_MAX_FRAG_LEN; 233 memcpy((uint8_t *) (desc->next_src_buf), 234 (uint8_t *) (unsigned long)(op->source_buf + SEC_MAX_FRAG_LEN), 235 desc->next_src_len); 236 237 op->source_buf_size = SEC_MAX_FRAG_LEN; 238 op->source_buf_size += iv_len; 239 } else { 240 /* copy IV into temporary kernel source buffer */ 241 memcpy(desc->user.aligned_src, &op->initial_vector[0], iv_len); 242 243 /* copy input data to temporary kernel source buffer */ 244 memcpy((uint8_t *) (desc->user.aligned_src + iv_len), 245 (uint8_t *) (unsigned long)op->source_buf, op->source_buf_size); 246 op->source_buf_size += iv_len; 247 } 248 } 249 250 /* Set source to new kernel space */ 251 op->source_buf = (uint64_t) (unsigned long)desc->user.aligned_src; 252 253 /* 254 * Build new dest buffer, for Cipher output only 255 */ 256 if (op->cipher_type == XLR_SEC_CIPHER_TYPE_NONE) { 257 /* 258 * Digest Engine *NEEDS* this, otherwise it will write at 259 * 0[x] 260 */ 261 op->dest_buf = (uint64_t) (unsigned long)desc->user.aligned_src; 262 } else { 263 /* DEBUG -dpk */ 264 XLR_SEC_CMD_DIAG("dest_buf_size = %d \n", op->dest_buf_size); 265 size = op->dest_buf_size + iv_len; 266 267 /* 268 * make sure that there are enough bytes for aes based 269 * stream ciphers 270 */ 271 if (op->cipher_mode == XLR_SEC_CIPHER_MODE_F8 || 272 op->cipher_mode == XLR_SEC_CIPHER_MODE_CTR) 273 size += XLR_SEC_AES_BLOCK_SIZE - 1; 274 op->dest_buf = (uint64_t) (unsigned long)desc->user.aligned_dest; 275 } 276 277 ret_val = xlr_sec_cipher_hash_command(op, desc, ses->multi_frag_flag); 278 return (ret_val); 279 280} 281 282static int 283xlr_sec_cipher_hash_command(xlr_sec_io_pt op, symkey_desc_pt desc, 284 uint8_t multi_frag_flag) 285{ 286 xlr_sec_error_t err; 287 uint32_t cfg_vector; 288 unsigned int setup_flags = 0; 289 290 err = XLR_SEC_ERR_NONE; 291 cfg_vector = 0; 292 293 if ((op->digest_type == XLR_SEC_DIGEST_TYPE_NONE) && 294 (op->cipher_type != XLR_SEC_CIPHER_TYPE_ARC4) && 295 (op->cipher_mode != XLR_SEC_CIPHER_MODE_F8) && 296 (op->cipher_type != XLR_SEC_CIPHER_TYPE_KASUMI_F8) && 297 (op->source_buf_size & 0x7)) { 298 printf("Invalid Cipher Block Size, data len=%d\n", 299 op->source_buf_size); 300 return (-EINVAL); 301 } 302 do { 303 304 if ((op->cipher_type == XLR_SEC_CIPHER_TYPE_3DES) && 305 (op->cipher_op == XLR_SEC_CIPHER_OP_DECRYPT)) 306 setup_flags = XLR_SEC_SETUP_OP_FLIP_3DES_KEY; 307 308 err = xlr_sec_setup_descriptor(op, 309 setup_flags, 310 desc, &cfg_vector); 311 if (err != XLR_SEC_ERR_NONE) 312 break; 313 314 err = xlr_sec_setup_packet(op, 315 desc, 316 op->digest_type != XLR_SEC_DIGEST_TYPE_NONE ? 317 XLR_SEC_SETUP_OP_CIPHER_HMAC : 0, 318 &desc->data, 319 &desc->pkt_desc[0], 320 &desc->ctl_desc, 321 cfg_vector, 322 &desc->pkt_desc[1], 323 multi_frag_flag); 324 if (err != XLR_SEC_ERR_NONE) 325 break; 326 } while (0); 327 if (err != XLR_SEC_ERR_NONE) { 328 return (EINVAL); 329 } 330 err = xlr_sec_submit_message(desc, cfg_vector); 331 return err; 332} 333 334static xlr_sec_error_t 335xlr_sec_setup_descriptor(xlr_sec_io_pt op, 336 unsigned int flags, 337 symkey_desc_pt desc, 338 uint32_t * cfg_vector) 339{ 340 xlr_sec_error_t err; 341 342 XLR_SEC_CMD_DIAG("xlr_sec_setup_descriptor: ENTER\n"); 343 344 if ((err = xlr_sec_setup_cipher(op, &desc->ctl_desc, cfg_vector)) != XLR_SEC_ERR_NONE) { 345 XLR_SEC_CMD_DIAG("xlr_sec_setup_descriptor: xlr_sec_setup_cipher done err %d\n", 346 (int)err); 347 return err; 348 } 349 if (op->digest_type != XLR_SEC_DIGEST_TYPE_NONE) { 350 if ((err = xlr_sec_setup_digest(op, &desc->ctl_desc, cfg_vector)) != XLR_SEC_ERR_NONE) { 351 XLR_SEC_CMD_DIAG("xlr_sec_setup_descriptor: xlr_sec_setup_digest done err %d\n", 352 (int)err); 353 return err; 354 } 355 } 356 if ((err = xlr_sec_setup_cksum(op, &desc->ctl_desc)) != XLR_SEC_ERR_NONE) { 357 XLR_SEC_CMD_DIAG("xlr_sec_setup_descriptor: xlr_sec_setup_cksum done err %d\n", 358 (int)err); 359 return err; 360 } 361 if ((err = xlr_sec_control_setup(op, 362 flags, 363 &desc->control, 364 &desc->ctl_desc, 365 &desc->user, 366 *cfg_vector)) != XLR_SEC_ERR_NONE) { 367 XLR_SEC_CMD_DIAG("xlr_sec_setup_descriptor: xlr_sec_control_setup done err %d\n", 368 (int)err); 369 return err; 370 } 371 XLR_SEC_CMD_DIAG("xlr_sec_setup_descriptor: DONE\n"); 372 return err; 373} 374 375 376 377static 378xlr_sec_error_t 379xlr_sec_setup_packet(xlr_sec_io_pt op, 380 symkey_desc_pt desc, 381 unsigned int flags, 382 uint64_t * data, 383 PacketDescriptor_pt pkt_desc, 384 ControlDescriptor_pt ctl_desc, 385 uint32_t vector, 386 PacketDescriptor_pt next_pkt_desc, 387 uint8_t multi_frag_flag) 388{ 389 uint32_t len, next_len = 0, len_dwords, last_u64_bytes; 390 uint64_t addr; 391 uint64_t seg_addr, next_seg_addr = 0; 392 uint64_t byte_offset, global_offset; 393 uint32_t cipher_offset_dwords; 394 395 XLR_SEC_CMD_DIAG("xlr_sec_setup_packet: ENTER vector = %04x\n", vector); 396 397 /* physical address of the source buffer */ 398 addr = (uint64_t) vtophys((void *)(unsigned long)op->source_buf); 399 /* cache-aligned base of the source buffer */ 400 seg_addr = (addr & ~(SMP_CACHE_BYTES - 1)); 401 /* offset in bytes to the source buffer start from the segment base */ 402 byte_offset = addr - seg_addr; 403 /* global offset: 0-7 bytes */ 404 global_offset = byte_offset & 0x7; 405 406 407 /* 408 * op->source_buf_size is expected to be the Nb double words to 409 * stream in (Including Segment address->CP/IV/Auth/CkSum offsets) 410 */ 411 412 /* 413 * adjusted length of the whole thing, accounting for the added 414 * head, sans global_offset (per Paul S.) 415 */ 416 417 len = op->source_buf_size + byte_offset - global_offset; 418 if (multi_frag_flag) { 419 next_seg_addr = (uint64_t)vtophys((void *)(uintptr_t)desc->next_src_buf); 420 next_seg_addr = (next_seg_addr & ~(SMP_CACHE_BYTES - 1)); 421 next_len = desc->next_src_len; 422 } 423 /* length of the whole thing in dwords */ 424 len_dwords = NUM_CHUNKS(len, 3); 425 /* number of bytes in the last chunk (len % 8) */ 426 last_u64_bytes = len & 0x07; 427 428 if (op->cipher_offset & 0x7) { 429 printf("** cipher_offset(%d) fails 64-bit word alignment **", 430 op->cipher_offset); 431 432 return XLR_SEC_ERR_CIPHER_MODE; /* ! fix ! */ 433 } 434 /* 435 * global_offset is only three bits, so work the number of the whole 436 * 8-byte words into the global offset. both offset and 437 * cipher_offset are byte counts 438 */ 439 cipher_offset_dwords = (op->iv_offset + byte_offset) >> 3; 440 441 if (op->cipher_mode == XLR_SEC_CIPHER_MODE_F8 || 442 op->cipher_mode == XLR_SEC_CIPHER_MODE_CTR) { 443 if (multi_frag_flag) { 444 int nlhmac = ((op->source_buf_size + global_offset + 7 - op->cipher_offset) >> 3) & 1; 445 446 pkt_desc->srcLengthIVOffUseIVNext = 447 FIELD_VALUE(PKT_DSC_HASHBYTES, len & 7) | 448 FIELD_VALUE(PKT_DSC_IVOFF, cipher_offset_dwords) | 449 FIELD_VALUE(PKT_DSC_PKTLEN, nlhmac + ((len + 7) >> 3)) | 450 FIELD_VALUE(PKT_DSC_NLHMAC, nlhmac) | 451 FIELD_VALUE(PKT_DSC_BREAK, 0) | 452 FIELD_VALUE(PKT_DSC_WAIT, 1) | 453 FIELD_VALUE(PKT_DSC_NEXT, 1) | 454 FIELD_VALUE(PKT_DSC_SEGADDR, seg_addr >> (PKT_DSC_SEGADDR_LSB)) | 455 FIELD_VALUE(PKT_DSC_SEGOFFSET, global_offset); 456 } else { 457 int nlhmac = ((op->source_buf_size + global_offset + 7 - op->cipher_offset) >> 3) & 1; 458 459 pkt_desc->srcLengthIVOffUseIVNext = 460 FIELD_VALUE(PKT_DSC_HASHBYTES, len & 7) | 461 FIELD_VALUE(PKT_DSC_IVOFF, cipher_offset_dwords) | 462 FIELD_VALUE(PKT_DSC_PKTLEN, nlhmac + ((len + 7) >> 3)) | 463 FIELD_VALUE(PKT_DSC_NLHMAC, nlhmac) | 464 FIELD_VALUE(PKT_DSC_BREAK, 0) | 465 FIELD_VALUE(PKT_DSC_WAIT, 0) | 466 FIELD_VALUE(PKT_DSC_SEGADDR, seg_addr >> (PKT_DSC_SEGADDR_LSB)) | 467 FIELD_VALUE(PKT_DSC_SEGOFFSET, global_offset); 468 469 } 470 } else { 471 if (multi_frag_flag) { 472 pkt_desc->srcLengthIVOffUseIVNext = 473 FIELD_VALUE(PKT_DSC_HASHBYTES, len & 7) | 474 FIELD_VALUE(PKT_DSC_IVOFF, cipher_offset_dwords) | 475 FIELD_VALUE(PKT_DSC_PKTLEN, (len + 7) >> 3) | 476 FIELD_VALUE(PKT_DSC_BREAK, 0) | 477 FIELD_VALUE(PKT_DSC_WAIT, 0) | 478 FIELD_VALUE(PKT_DSC_NEXT, 1) | 479 FIELD_VALUE(PKT_DSC_SEGADDR, seg_addr >> (PKT_DSC_SEGADDR_LSB)) | 480 FIELD_VALUE(PKT_DSC_SEGOFFSET, global_offset); 481 482 483 next_pkt_desc->srcLengthIVOffUseIVNext = 484 FIELD_VALUE(PKT_DSC_HASHBYTES, (next_len & 7)) | 485 FIELD_VALUE(PKT_DSC_IVOFF, 0) | 486 FIELD_VALUE(PKT_DSC_PKTLEN, (next_len + 7) >> 3) | 487 FIELD_VALUE(PKT_DSC_BREAK, 0) | 488 FIELD_VALUE(PKT_DSC_WAIT, 0) | 489 FIELD_VALUE(PKT_DSC_NEXT, 0) | 490 FIELD_VALUE(PKT_DSC_SEGADDR, next_seg_addr >> (PKT_DSC_SEGADDR_LSB)) | 491 FIELD_VALUE(PKT_DSC_SEGOFFSET, 0); 492 493 494 } else { 495 pkt_desc->srcLengthIVOffUseIVNext = 496 FIELD_VALUE(PKT_DSC_HASHBYTES, len & 7) | 497 FIELD_VALUE(PKT_DSC_IVOFF, cipher_offset_dwords) | 498 FIELD_VALUE(PKT_DSC_PKTLEN, (len + 7) >> 3) | 499 FIELD_VALUE(PKT_DSC_BREAK, 0) | 500 FIELD_VALUE(PKT_DSC_WAIT, 0) | 501 FIELD_VALUE(PKT_DSC_SEGADDR, seg_addr >> (PKT_DSC_SEGADDR_LSB)) | 502 FIELD_VALUE(PKT_DSC_SEGOFFSET, global_offset); 503 504 505 } 506 } 507 508 switch (op->pkt_hmac) { 509 case XLR_SEC_LOADHMACKEY_MODE_OLD: 510 CLEAR_SET_FIELD(pkt_desc->srcLengthIVOffUseIVNext, 511 PKT_DSC_LOADHMACKEY, PKT_DSC_LOADHMACKEY_OLD); 512 if (multi_frag_flag) { 513 CLEAR_SET_FIELD(next_pkt_desc->srcLengthIVOffUseIVNext, 514 PKT_DSC_LOADHMACKEY, PKT_DSC_LOADHMACKEY_OLD); 515 516 } 517 break; 518 case XLR_SEC_LOADHMACKEY_MODE_LOAD: 519 CLEAR_SET_FIELD(pkt_desc->srcLengthIVOffUseIVNext, 520 PKT_DSC_LOADHMACKEY, PKT_DSC_LOADHMACKEY_LOAD); 521 if (multi_frag_flag) { 522 CLEAR_SET_FIELD(next_pkt_desc->srcLengthIVOffUseIVNext, 523 PKT_DSC_LOADHMACKEY, PKT_DSC_LOADHMACKEY_LOAD); 524 525 } 526 break; 527 default: 528 if (vector & (XLR_SEC_VECTOR_HMAC | XLR_SEC_VECTOR_HMAC2 | XLR_SEC_VECTOR_GCM | XLR_SEC_VECTOR_F9)) { 529 XLR_SEC_CMD_DIAG("xlr_sec_setup_packet: ERR_LOADHMACKEY_MODE EXIT\n"); 530 return XLR_SEC_ERR_LOADHMACKEY_MODE; 531 } 532 break; 533 } 534 535 switch (op->pkt_hash) { 536 case XLR_SEC_PADHASH_PADDED: 537 CLEAR_SET_FIELD(pkt_desc->srcLengthIVOffUseIVNext, 538 PKT_DSC_PADHASH, PKT_DSC_PADHASH_PADDED); 539 if (multi_frag_flag) { 540 CLEAR_SET_FIELD(next_pkt_desc->srcLengthIVOffUseIVNext, 541 PKT_DSC_PADHASH, PKT_DSC_PADHASH_PADDED); 542 } 543 break; 544 case XLR_SEC_PADHASH_PAD: 545 CLEAR_SET_FIELD(pkt_desc->srcLengthIVOffUseIVNext, 546 PKT_DSC_PADHASH, PKT_DSC_PADHASH_PAD); 547 if (multi_frag_flag) { 548 CLEAR_SET_FIELD(next_pkt_desc->srcLengthIVOffUseIVNext, 549 PKT_DSC_PADHASH, PKT_DSC_PADHASH_PAD); 550 } 551 break; 552 default: 553 if (vector & (XLR_SEC_VECTOR_MAC | XLR_SEC_VECTOR_HMAC | XLR_SEC_VECTOR_HMAC2)) { 554 XLR_SEC_CMD_DIAG("xlr_sec_setup_packet: ERR_PADHASH_MODE EXIT\n"); 555 return XLR_SEC_ERR_PADHASH_MODE; 556 } 557 break; 558 } 559 560 switch (op->pkt_iv) { 561 case XLR_SEC_PKT_IV_OLD: 562 CLEAR_SET_FIELD(pkt_desc->srcLengthIVOffUseIVNext, 563 PKT_DSC_IV, PKT_DSC_IV_OLD); 564 if (multi_frag_flag) { 565 CLEAR_SET_FIELD(next_pkt_desc->srcLengthIVOffUseIVNext, 566 PKT_DSC_IV, PKT_DSC_IV_OLD); 567 568 } 569 break; 570 case XLR_SEC_PKT_IV_NEW: 571 CLEAR_SET_FIELD(pkt_desc->srcLengthIVOffUseIVNext, 572 PKT_DSC_IV, PKT_DSC_IV_NEW); 573 if (multi_frag_flag) { 574 CLEAR_SET_FIELD(next_pkt_desc->srcLengthIVOffUseIVNext, 575 PKT_DSC_IV, PKT_DSC_IV_NEW); 576 577 } 578 break; 579 default: 580 if (vector & XLR_SEC_VECTOR_CIPHER) { 581 XLR_SEC_CMD_DIAG("xlr_sec_setup_packet: ERR_PKT_IV_MODE EXIT\n"); 582 return XLR_SEC_ERR_PKT_IV_MODE; 583 } 584 break; 585 } 586 587 XLR_SEC_CMD_DIAG("xlr_sec_setup_packet: src_buf=%llx phys_src_buf=%llx \n", 588 (unsigned long long)op->source_buf, (unsigned long long)addr); 589 590 XLR_SEC_CMD_DIAG("xlr_sec_setup_packet: seg_addr=%llx offset=%lld\n", 591 (unsigned long long)seg_addr, (unsigned long long)byte_offset); 592 593 XLR_SEC_CMD_DIAG("xlr_sec_setup_packet: global src offset: %d, iv_offset=%d\n", 594 cipher_offset_dwords, op->iv_offset); 595 596 XLR_SEC_CMD_DIAG("xlr_sec_setup_packet: src_buf_sz=%d PKT_LEN=%d\n", 597 op->source_buf_size, len_dwords); 598 599 /* 600 * same operation with the destination. cipher offset affects this, 601 * as well 602 */ 603 if (multi_frag_flag) { 604 next_seg_addr = (uint64_t) vtophys((void *)(unsigned long)(desc->next_dest_buf)); 605 next_seg_addr = (next_seg_addr & ~(SMP_CACHE_BYTES - 1)); 606 } 607 addr = (uint64_t) vtophys((void *)(unsigned long)op->dest_buf); 608 seg_addr = (addr & ~(SMP_CACHE_BYTES - 1)); 609 byte_offset = addr - seg_addr; 610 global_offset = byte_offset & 0x7; 611 612 XLR_SEC_CMD_DIAG("xlr_sec_setup_packet: dest_buf=%llx phys_dest_buf=%llx \n", 613 (unsigned long long)op->dest_buf, (unsigned long long)addr); 614 615 XLR_SEC_CMD_DIAG("xlr_sec_setup_packet: seg_addr=%llx offset=%lld\n", 616 (unsigned long long)seg_addr, (unsigned long long)byte_offset); 617 618 /* 619 * Dest Address = (Cipher Dest Address) + (Cipher Offset) + (Global 620 * Dest Data Offset) 621 * 622 * Cipher Dest Address - Cache-line (0xffffffffe0) Cipher Offset - 623 * Which (64-bit) Word in Cacheline (0-3) Global Dest Data Offset - 624 * Number of Bytes in (64-bit) Word before data 625 * 626 * It must be set for Digest-only Ops, since the Digest engine will 627 * write data to this address. 628 */ 629 cipher_offset_dwords = (op->cipher_offset + byte_offset) >> 3; 630 631 632 pkt_desc->dstDataSettings = 633 /* SYM_OP, HASHSRC */ 634 FIELD_VALUE(PKT_DSC_CPHROFF, cipher_offset_dwords) | 635 FIELD_VALUE(PKT_DSC_HASHOFF, (op->digest_offset + byte_offset) >> 3) | 636 FIELD_VALUE(PKT_DSC_CPHR_DST_ADDR, seg_addr) | 637 FIELD_VALUE(PKT_DSC_CPHR_DST_DWOFFSET, 0) | 638 FIELD_VALUE(PKT_DSC_CPHR_DST_OFFSET, global_offset); 639 640 if (multi_frag_flag) { 641 next_pkt_desc->dstDataSettings = 642 /* SYM_OP, HASHSRC */ 643 FIELD_VALUE(PKT_DSC_CPHROFF, cipher_offset_dwords) | 644 FIELD_VALUE(PKT_DSC_HASHOFF, (op->digest_offset + byte_offset) >> 3) | 645 FIELD_VALUE(PKT_DSC_CPHR_DST_ADDR, next_seg_addr) | 646 FIELD_VALUE(PKT_DSC_CPHR_DST_DWOFFSET, 0) | 647 FIELD_VALUE(PKT_DSC_CPHR_DST_OFFSET, global_offset); 648 649 } 650 if (op->cipher_type == XLR_SEC_CIPHER_TYPE_ARC4) 651 pkt_desc->dstDataSettings |= FIELD_VALUE(PKT_DSC_ARC4BYTECOUNT, last_u64_bytes); 652 653 if (op->cipher_type != XLR_SEC_CIPHER_TYPE_NONE) { 654 switch (op->cipher_op) { 655 case XLR_SEC_CIPHER_OP_ENCRYPT: 656 CLEAR_SET_FIELD(pkt_desc->dstDataSettings, 657 PKT_DSC_SYM_OP, PKT_DSC_SYM_OP_ENCRYPT); 658 if (multi_frag_flag) { 659 CLEAR_SET_FIELD(next_pkt_desc->dstDataSettings, 660 PKT_DSC_SYM_OP, PKT_DSC_SYM_OP_ENCRYPT); 661 662 } 663 break; 664 case XLR_SEC_CIPHER_OP_DECRYPT: 665 CLEAR_SET_FIELD(pkt_desc->dstDataSettings, 666 PKT_DSC_SYM_OP, PKT_DSC_SYM_OP_DECRYPT); 667 if (multi_frag_flag) { 668 CLEAR_SET_FIELD(next_pkt_desc->dstDataSettings, 669 PKT_DSC_SYM_OP, PKT_DSC_SYM_OP_DECRYPT); 670 671 } 672 break; 673 default: 674 XLR_SEC_CMD_DIAG("xlr_sec_setup_packet: ERR_CIPHER_OP EXIT\n"); 675 return XLR_SEC_ERR_CIPHER_OP; 676 } 677 } 678 if (flags & XLR_SEC_SETUP_OP_HMAC) { 679 switch (op->digest_src) { 680 case XLR_SEC_DIGEST_SRC_DMA: 681 CLEAR_SET_FIELD(pkt_desc->dstDataSettings, 682 PKT_DSC_HASHSRC, PKT_DSC_HASHSRC_DMA); 683 if (multi_frag_flag) { 684 CLEAR_SET_FIELD(next_pkt_desc->dstDataSettings, 685 PKT_DSC_HASHSRC, PKT_DSC_HASHSRC_DMA); 686 687 } 688 break; 689 case XLR_SEC_DIGEST_SRC_CPHR: 690 CLEAR_SET_FIELD(pkt_desc->dstDataSettings, 691 PKT_DSC_HASHSRC, PKT_DSC_HASHSRC_CIPHER); 692 if (multi_frag_flag) { 693 CLEAR_SET_FIELD(next_pkt_desc->dstDataSettings, 694 PKT_DSC_HASHSRC, PKT_DSC_HASHSRC_CIPHER); 695 } 696 break; 697 default: 698 XLR_SEC_CMD_DIAG("xlr_sec_setup_packet: ERR_DIGEST_SRC EXIT\n"); 699 return XLR_SEC_ERR_DIGEST_SRC; 700 } 701 } 702 if (op->cksum_type != XLR_SEC_CKSUM_TYPE_NOP) { 703 switch (op->cksum_src) { 704 case XLR_SEC_CKSUM_SRC_DMA: 705 CLEAR_SET_FIELD(pkt_desc->dstDataSettings, 706 PKT_DSC_CKSUMSRC, PKT_DSC_CKSUMSRC_DMA); 707 if (multi_frag_flag) { 708 CLEAR_SET_FIELD(next_pkt_desc->dstDataSettings, 709 PKT_DSC_CKSUMSRC, PKT_DSC_CKSUMSRC_DMA); 710 } 711 break; 712 case XLR_SEC_CKSUM_SRC_CIPHER: 713 CLEAR_SET_FIELD(next_pkt_desc->dstDataSettings, 714 PKT_DSC_CKSUMSRC, PKT_DSC_CKSUMSRC_CIPHER); 715 if (multi_frag_flag) { 716 CLEAR_SET_FIELD(next_pkt_desc->dstDataSettings, 717 PKT_DSC_CKSUMSRC, PKT_DSC_CKSUMSRC_CIPHER); 718 } 719 break; 720 default: 721 XLR_SEC_CMD_DIAG("xlr_sec_setup_packet: ERR_CKSUM_SRC EXIT\n"); 722 return XLR_SEC_ERR_CKSUM_SRC; 723 } 724 } 725 pkt_desc->ckSumDstNonceHiCFBMaskLLWMask = 726 FIELD_VALUE(PKT_DSC_HASH_BYTE_OFF, (op->digest_offset & 0x7)) | 727 FIELD_VALUE(PKT_DSC_PKTLEN_BYTES, 0) | 728 /* NONCE_HI, PKT_DSC_LASTWORD, CFB_MASK, CKSUM_DST_ADDR */ 729 FIELD_VALUE(PKT_DSC_IV_OFF_HI, 0); 730 731 if (multi_frag_flag) { 732 next_pkt_desc->ckSumDstNonceHiCFBMaskLLWMask = 733 FIELD_VALUE(PKT_DSC_HASH_BYTE_OFF, (op->digest_offset & 0x7)) | 734 FIELD_VALUE(PKT_DSC_PKTLEN_BYTES, 0) | 735 /* NONCE_HI, PKT_DSC_LASTWORD, CFB_MASK, CKSUM_DST_ADDR */ 736 FIELD_VALUE(PKT_DSC_IV_OFF_HI, 0); 737 738 } 739 switch (op->pkt_lastword) { 740 case XLR_SEC_LASTWORD_128: 741 CLEAR_SET_FIELD(pkt_desc->ckSumDstNonceHiCFBMaskLLWMask, 742 PKT_DSC_LASTWORD, PKT_DSC_LASTWORD_128); 743 if (multi_frag_flag) { 744 CLEAR_SET_FIELD(next_pkt_desc->ckSumDstNonceHiCFBMaskLLWMask, 745 PKT_DSC_LASTWORD, PKT_DSC_LASTWORD_128); 746 747 } 748 break; 749 case XLR_SEC_LASTWORD_96MASK: 750 CLEAR_SET_FIELD(pkt_desc->ckSumDstNonceHiCFBMaskLLWMask, 751 PKT_DSC_LASTWORD, PKT_DSC_LASTWORD_96MASK); 752 if (multi_frag_flag) { 753 CLEAR_SET_FIELD(next_pkt_desc->ckSumDstNonceHiCFBMaskLLWMask, 754 PKT_DSC_LASTWORD, PKT_DSC_LASTWORD_96MASK); 755 } 756 break; 757 case XLR_SEC_LASTWORD_64MASK: 758 CLEAR_SET_FIELD(pkt_desc->ckSumDstNonceHiCFBMaskLLWMask, 759 PKT_DSC_LASTWORD, PKT_DSC_LASTWORD_64MASK); 760 if (multi_frag_flag) { 761 CLEAR_SET_FIELD(next_pkt_desc->ckSumDstNonceHiCFBMaskLLWMask, 762 PKT_DSC_LASTWORD, PKT_DSC_LASTWORD_64MASK); 763 } 764 break; 765 case XLR_SEC_LASTWORD_32MASK: 766 CLEAR_SET_FIELD(pkt_desc->ckSumDstNonceHiCFBMaskLLWMask, 767 PKT_DSC_LASTWORD, PKT_DSC_LASTWORD_32MASK); 768 if (multi_frag_flag) { 769 CLEAR_SET_FIELD(next_pkt_desc->ckSumDstNonceHiCFBMaskLLWMask, 770 PKT_DSC_LASTWORD, PKT_DSC_LASTWORD_32MASK); 771 } 772 break; 773 default: 774 XLR_SEC_CMD_DIAG("xlr_sec_setup_packet: ERR_LASTWORD_MODE EXIT\n"); 775 return XLR_SEC_ERR_LASTWORD_MODE; 776 } 777 CLEAR_SET_FIELD(pkt_desc->ckSumDstNonceHiCFBMaskLLWMask, 778 PKT_DSC_CFB_MASK, op->cfb_mask); 779 CLEAR_SET_FIELD(pkt_desc->ckSumDstNonceHiCFBMaskLLWMask, 780 PKT_DSC_NONCE_HI, htonl(op->nonce) >> 24); 781 CLEAR_SET_FIELD(pkt_desc->authDstNonceLow, 782 PKT_DSC_NONCE_LOW, htonl(op->nonce) & 0xffffff); 783 784 if (multi_frag_flag) { 785 CLEAR_SET_FIELD(next_pkt_desc->ckSumDstNonceHiCFBMaskLLWMask, 786 PKT_DSC_CFB_MASK, op->cfb_mask); 787 CLEAR_SET_FIELD(next_pkt_desc->ckSumDstNonceHiCFBMaskLLWMask, 788 PKT_DSC_NONCE_HI, htonl(op->nonce) >> 24); 789 CLEAR_SET_FIELD(next_pkt_desc->authDstNonceLow, 790 PKT_DSC_NONCE_LOW, htonl(op->nonce) & 0xffffff); 791 792 793 } 794 /* Auth Dest Address must be Cacheline aligned on input */ 795 if (vector & (XLR_SEC_VECTOR_MAC | XLR_SEC_VECTOR_HMAC | XLR_SEC_VECTOR_HMAC2 | XLR_SEC_VECTOR_GCM | XLR_SEC_VECTOR_F9)) { 796 pkt_desc->authDstNonceLow |= 797 /* NONCE_LOW */ 798 FIELD_VALUE(PKT_DSC_AUTH_DST_ADDR, 799 (uint64_t) vtophys((void *)(unsigned long)op->auth_dest)) | 800 FIELD_VALUE(PKT_DSC_CIPH_OFF_HI, 0); 801 802 803 if (multi_frag_flag) { 804 next_pkt_desc->authDstNonceLow |= 805 /* NONCE_LOW */ 806 FIELD_VALUE(PKT_DSC_AUTH_DST_ADDR, 807 (uint64_t) vtophys((void *)(unsigned long)desc->next_auth_dest)) | 808 FIELD_VALUE(PKT_DSC_CIPH_OFF_HI, 0); 809 810 811 } 812 } 813 /* CkSum Dest Address must be Cacheline aligned on input */ 814 if (op->cksum_type == XLR_SEC_CKSUM_TYPE_IP) { 815 CLEAR_SET_FIELD(pkt_desc->ckSumDstNonceHiCFBMaskLLWMask, 816 PKT_DSC_CKSUM_DST_ADDR, 817 (uint64_t) vtophys((void *)(unsigned long)op->cksum_dest)); 818 819 if (multi_frag_flag) { 820 CLEAR_SET_FIELD(next_pkt_desc->ckSumDstNonceHiCFBMaskLLWMask, 821 PKT_DSC_CKSUM_DST_ADDR, 822 (uint64_t) vtophys((void *)(unsigned long)desc->next_cksum_dest)); 823 } 824 } 825 /* 826 * XLR_SEC_CMD_DIAG (" xlr_sec_setup_packet(): pkt_desc=%llx 827 * phys_pkt_desc=%llx \n", (unsigned long long)pkt_desc, (unsigned 828 * long long)virt_to_phys(pkt_desc)); (unsigned long long)pkt_desc, 829 * (unsigned long long)vtophys(pkt_desc)); 830 */ 831 XLR_SEC_CMD_DIAG(" xlr_sec_setup_packet(): pkt_desc=%p phys_pkt_desc=%llx \n", 832 pkt_desc, (unsigned long long)vtophys(pkt_desc)); 833 834 CLEAR_SET_FIELD(*data, MSG_CMD_DATA_ADDR, ((uint64_t) vtophys(pkt_desc))); 835 CLEAR_SET_FIELD(*data, MSG_CMD_DATA_CTL, SEC_EOP); 836 CLEAR_SET_FIELD(*data, MSG_CMD_DATA_LEN, MSG_CMD_DATA_LEN_LOAD); 837 838 XLR_SEC_CMD_DIAG("xlr_sec_setup_packet: DONE\n"); 839 840#ifdef RMI_SEC_DEBUG 841 { 842 printf("data desc\n"); 843 printf("srcLengthIVOffUseIVNext = 0x%llx\n", pkt_desc->srcLengthIVOffUseIVNext); 844 printf("dstDataSettings = 0x%llx\n", pkt_desc->dstDataSettings); 845 printf("authDstNonceLow = 0x%llx\n", pkt_desc->authDstNonceLow); 846 printf("ckSumDstNonceHiCFBMaskLLWMask = 0x%llx\n", pkt_desc->ckSumDstNonceHiCFBMaskLLWMask); 847 } 848 849 if (multi_frag_flag) { 850 851 printf("next data desc\n"); 852 printf("srcLengthIVOffUseIVNext = 0x%llx\n", next_pkt_desc->srcLengthIVOffUseIVNext); 853 printf("dstDataSettings = 0x%llx\n", next_pkt_desc->dstDataSettings); 854 printf("authDstNonceLow = 0x%llx\n", next_pkt_desc->authDstNonceLow); 855 printf("ckSumDstNonceHiCFBMaskLLWMask = 0x%llx\n", next_pkt_desc->ckSumDstNonceHiCFBMaskLLWMask); 856 } 857#endif 858 859#ifdef SYMBOL 860 if (op->cipher_type == XLR_SEC_CIPHER_TYPE_ARC4) { 861 op->source_buf -= 0; 862 op->source_buf_size += 0; 863 op->dest_buf -= 0; 864 } 865#endif 866 return XLR_SEC_ERR_NONE; 867} 868 869 870static int 871identify_symkey_ctl_error(uint32_t code, xlr_sec_error_t err) 872{ 873 int ret_val = EINVAL; 874 875 switch (code) { 876 case CTL_ERR_NONE: 877 XLR_SEC_CMD_DIAG("XLR_SEC_SEC: CTL Error: No Error\n"); 878 ret_val = 0; 879 break; 880 case CTL_ERR_CIPHER_OP: 881 XLR_SEC_CMD_DIAG("XLR_SEC_SEC: CTL Error(CTL_ERR_CIPHER_OP) - Unknown Cipher Op \n"); 882 break; 883 case CTL_ERR_MODE: 884 XLR_SEC_CMD_DIAG("XLR_SEC_SEC: CTL Error(CTL_ERR_MODE) - " 885 "Unknown or Not Allowed Mode \n"); 886 break; 887 case CTL_ERR_CHKSUM_SRC: 888 XLR_SEC_CMD_DIAG("XLR_SEC_SEC: CTL Error(CTL_ERR_CHKSUM_SRC) - Unknown CkSum Src\n"); 889 break; 890 case CTL_ERR_CFB_MASK: 891 XLR_SEC_CMD_DIAG("XLR_SEC_SEC: CTL Error(CTL_ERR_CFB_MASK) - Forbidden CFB Mask \n"); 892 break; 893 case CTL_ERR_OP: 894 XLR_SEC_CMD_DIAG("XLR_SEC_SEC: CTL Error(CTL_ERR_OP) - Unknown Ctrl Op \n"); 895 break; 896 case CTL_ERR_DATA_READ: 897 XLR_SEC_CMD_DIAG("XLR_SEC_SEC: CTL Error(CTL_ERR_DATA_READ) - Data Read Error\n"); 898 break; 899 case CTL_ERR_DESC_CTRL: 900 XLR_SEC_CMD_DIAG("XLR_SEC_SEC: CTL Error(CTL_ERR_DESC_CTRL) - " 901 "Descriptor Ctrl Field Error \n"); 902 break; 903 case CTL_ERR_UNDEF1: 904 case CTL_ERR_UNDEF2: 905 default: 906 XLR_SEC_CMD_DIAG("XLR_SEC_SEC: CTL Error: UNKNOWN CODE=%d \n", code); 907 break; 908 } 909 return ret_val; 910} 911 912static 913int 914identify_symkey_data_error(uint32_t code, xlr_sec_error_t err) 915{ 916 int ret_val = -EINVAL; 917 918 switch (code) { 919 case DATA_ERR_NONE: 920 XLR_SEC_CMD_DIAG("XLR_SEC_SEC: DATA Error No Error\n"); 921 ret_val = 0; 922 break; 923 case DATA_ERR_LEN_CIPHER: 924 XLR_SEC_CMD_DIAG("XLR_SEC_SEC: DATA Error() - Not Enough Data To Cipher\n"); 925 break; 926 case DATA_ERR_IV_ADDR: 927 XLR_SEC_CMD_DIAG("XLR_SEC_SEC: DATA Error() - Illegal IV Loacation\n"); 928 break; 929 case DATA_ERR_WD_LEN_AES: 930 XLR_SEC_CMD_DIAG("XLR_SEC_SEC: DATA Error() - Illegal Nb Words To AES\n"); 931 break; 932 case DATA_ERR_BYTE_COUNT: 933 XLR_SEC_CMD_DIAG("XLR_SEC_SEC: DATA Error() - Illegal Pad And ByteCount Spec\n"); 934 break; 935 case DATA_ERR_LEN_CKSUM: 936 XLR_SEC_CMD_DIAG("XLR_SEC_SEC: DATA Error() - Not Enough Data To CkSum\n"); 937 break; 938 case DATA_ERR_OP: 939 XLR_SEC_CMD_DIAG("XLR_SEC_SEC: DATA Error() - Unknown Data Op \n"); 940 break; 941 case DATA_ERR_READ: 942 XLR_SEC_CMD_DIAG("XLR_SEC_SEC: DATA Error() - Data Read Error \n"); 943 break; 944 case DATA_ERR_WRITE: 945 XLR_SEC_CMD_DIAG("XLR_SEC_SEC: DATA Error() - Data Write Error \n"); 946 break; 947 case DATA_ERR_UNDEF1: 948 default: 949 XLR_SEC_CMD_DIAG("XLR_SEC_SEC: DATA Error - UNKNOWN CODE=%d \n", code); 950 break; 951 } 952 return ret_val; 953} 954 955 956static int 957xlr_sec_submit_message(symkey_desc_pt desc, uint32_t cfg_vector) 958{ 959 xlr_sec_error_t err; 960 uint32_t ctl_error, data_error; 961 int ret_val = 0; 962 963 XLR_SEC_CMD_DIAG("xlr_sec_submit_message: ENTER\n"); 964 err = XLR_SEC_ERR_NONE; 965 XLR_SEC_CMD_DIAG_SYM_DESC(desc, cfg_vector); 966 967 do { 968 /* For now, send message and wait for response */ 969 err = xlr_sec_submit_op(desc); 970 971 XLR_SEC_CMD_DIAG("xlr_sec_submit_message: err = %d \n", (uint32_t) err); 972 973 if (err != XLR_SEC_ERR_NONE) { 974 ret_val = (EINVAL); 975 break; 976 } 977 ctl_error = desc->ctl_result; 978 data_error = desc->data_result; 979 980 XLR_SEC_CMD_DIAG("xlr_sec_submit_message: ctl_error = %x data_error = %x\n", 981 ctl_error, data_error); 982 983 if ((ret_val = identify_symkey_ctl_error(ctl_error, err)) == 0) 984 ret_val = identify_symkey_data_error(data_error, err); 985 986 XLR_SEC_CMD_DIAG("xlr_sec_submit_message: identify error = %d \n", ret_val); 987 988 } while (0); 989 990 XLR_SEC_CMD_DIAG("xlr_sec_submit_message: DONE\n"); 991 return (ret_val); 992} 993 994 995static 996xlr_sec_error_t 997xlr_sec_setup_cipher(xlr_sec_io_pt op, 998 ControlDescriptor_pt ctl_desc, 999 uint32_t * vector) 1000{ 1001 uint32_t aes_flag = 0; 1002 uint32_t cipher_vector = 0; 1003 1004 XLR_SEC_CMD_DIAG("xlr_sec_setup_cipher: ENTER vector = %04x\n", *vector); 1005 1006 switch (op->cipher_type) { 1007 case XLR_SEC_CIPHER_TYPE_NONE: 1008 SET_FIELD(ctl_desc->instruction, CTL_DSC_CPHR, CTL_DSC_CPHR_BYPASS); 1009 XLR_SEC_CMD_DIAG("xlr_sec_setup_cipher: CIPHER_TYPE_NONE EXIT\n"); 1010 return XLR_SEC_ERR_NONE; 1011 case XLR_SEC_CIPHER_TYPE_DES: 1012 cipher_vector |= XLR_SEC_VECTOR_CIPHER_DES; 1013 SET_FIELD(ctl_desc->instruction, CTL_DSC_CPHR, CTL_DSC_CPHR_DES); 1014 break; 1015 case XLR_SEC_CIPHER_TYPE_3DES: 1016 cipher_vector |= XLR_SEC_VECTOR_CIPHER_3DES; 1017 SET_FIELD(ctl_desc->instruction, CTL_DSC_CPHR, CTL_DSC_CPHR_3DES); 1018 break; 1019 case XLR_SEC_CIPHER_TYPE_AES128: 1020 aes_flag = 1; 1021 cipher_vector |= XLR_SEC_VECTOR_CIPHER_AES128; 1022 SET_FIELD(ctl_desc->instruction, CTL_DSC_CPHR, CTL_DSC_CPHR_AES128); 1023 break; 1024 case XLR_SEC_CIPHER_TYPE_AES192: 1025 aes_flag = 1; 1026 cipher_vector |= XLR_SEC_VECTOR_CIPHER_AES192; 1027 SET_FIELD(ctl_desc->instruction, CTL_DSC_CPHR, CTL_DSC_CPHR_AES192); 1028 break; 1029 case XLR_SEC_CIPHER_TYPE_AES256: 1030 aes_flag = 1; 1031 cipher_vector |= XLR_SEC_VECTOR_CIPHER_AES256; 1032 SET_FIELD(ctl_desc->instruction, CTL_DSC_CPHR, CTL_DSC_CPHR_AES256); 1033 break; 1034 case XLR_SEC_CIPHER_TYPE_ARC4: 1035 cipher_vector |= XLR_SEC_VECTOR_CIPHER_ARC4; 1036 SET_FIELD(ctl_desc->instruction, CTL_DSC_CPHR, CTL_DSC_CPHR_ARC4); 1037 SET_FIELD(ctl_desc->instruction, CTL_DSC_ARC4_KEYLEN, 1038 op->rc4_key_len); 1039 SET_FIELD(ctl_desc->instruction, CTL_DSC_ARC4_LOADSTATE, 1040 op->rc4_loadstate); 1041 SET_FIELD(ctl_desc->instruction, CTL_DSC_ARC4_SAVESTATE, 1042 op->rc4_savestate); 1043 if (op->rc4_loadstate || op->rc4_savestate) 1044 cipher_vector |= XLR_SEC_VECTOR_STATE; 1045 break; 1046 case XLR_SEC_CIPHER_TYPE_KASUMI_F8: 1047 aes_flag = 1; 1048 cipher_vector |= XLR_SEC_VECTOR_CIPHER_KASUMI_F8; 1049 SET_FIELD(ctl_desc->instruction, CTL_DSC_CPHR, CTL_DSC_CPHR_KASUMI_F8); 1050 break; 1051 default: 1052 XLR_SEC_CMD_DIAG("xlr_sec_setup_cipher: ERR_CIPHER_TYPE EXIT\n"); 1053 return XLR_SEC_ERR_CIPHER_TYPE; 1054 } 1055 1056 switch (op->cipher_mode) { 1057 case XLR_SEC_CIPHER_MODE_ECB: 1058 if (aes_flag == 1) 1059 cipher_vector |= XLR_SEC_VECTOR_MODE_ECB_CBC_OFB; 1060 else 1061 cipher_vector |= XLR_SEC_VECTOR_MODE_ECB_CBC; 1062 SET_FIELD(ctl_desc->instruction, CTL_DSC_MODE, CTL_DSC_MODE_ECB); 1063 break; 1064 case XLR_SEC_CIPHER_MODE_CBC: 1065 if (aes_flag == 1) 1066 cipher_vector |= XLR_SEC_VECTOR_MODE_ECB_CBC_OFB; 1067 else 1068 cipher_vector |= XLR_SEC_VECTOR_MODE_ECB_CBC; 1069 SET_FIELD(ctl_desc->instruction, CTL_DSC_MODE, CTL_DSC_MODE_CBC); 1070 break; 1071 case XLR_SEC_CIPHER_MODE_OFB: 1072 if (aes_flag == 0) { 1073 XLR_SEC_CMD_DIAG("xlr_sec_setup_cipher: ERR_CIPHER_MODE EXIT\n"); 1074 return XLR_SEC_ERR_CIPHER_MODE; 1075 } 1076 cipher_vector |= XLR_SEC_VECTOR_MODE_ECB_CBC_OFB; 1077 SET_FIELD(ctl_desc->instruction, CTL_DSC_MODE, CTL_DSC_MODE_OFB); 1078 break; 1079 case XLR_SEC_CIPHER_MODE_CTR: 1080 if (aes_flag == 0) { 1081 XLR_SEC_CMD_DIAG("xlr_sec_setup_cipher: ERR_CIPHER_MODE EXIT\n"); 1082 return XLR_SEC_ERR_CIPHER_MODE; 1083 } 1084 cipher_vector |= XLR_SEC_VECTOR_MODE_CTR_CFB; 1085 SET_FIELD(ctl_desc->instruction, CTL_DSC_MODE, CTL_DSC_MODE_CTR); 1086 break; 1087 case XLR_SEC_CIPHER_MODE_CFB: 1088 if (aes_flag == 0) { 1089 XLR_SEC_CMD_DIAG("xlr_sec_setup_cipher: ERR_CIPHER_MODE EXIT\n"); 1090 return XLR_SEC_ERR_CIPHER_MODE; 1091 } 1092 cipher_vector |= XLR_SEC_VECTOR_MODE_CTR_CFB; 1093 SET_FIELD(ctl_desc->instruction, CTL_DSC_MODE, CTL_DSC_MODE_CFB); 1094 break; 1095 case XLR_SEC_CIPHER_MODE_F8: 1096 if (aes_flag == 0) { 1097 XLR_SEC_CMD_DIAG("xlr_sec_setup_cipher: ERR_CIPHER_MODE EXIT\n"); 1098 return XLR_SEC_ERR_CIPHER_MODE; 1099 } 1100 cipher_vector |= XLR_SEC_VECTOR_MODE_F8; 1101 SET_FIELD(ctl_desc->instruction, CTL_DSC_MODE, CTL_DSC_MODE_F8); 1102 break; 1103 default: 1104 if (!(cipher_vector & (XLR_SEC_VECTOR_CIPHER_ARC4 | XLR_SEC_VECTOR_CIPHER_KASUMI_F8))) { 1105 XLR_SEC_CMD_DIAG("xlr_sec_setup_cipher: ERR_CIPHER_MODE EXIT\n"); 1106 return XLR_SEC_ERR_CIPHER_MODE; 1107 } 1108 } 1109 1110 switch (op->cipher_init) { 1111 case XLR_SEC_CIPHER_INIT_OK: 1112 SET_FIELD(ctl_desc->instruction, 1113 CTL_DSC_ICPHR, CTL_DSC_ICPHR_OKY); 1114 break; 1115 1116 case XLR_SEC_CIPHER_INIT_NK: 1117 SET_FIELD(ctl_desc->instruction, 1118 CTL_DSC_ICPHR, CTL_DSC_ICPHR_NKY); 1119 break; 1120 default: 1121 XLR_SEC_CMD_DIAG("xlr_sec_setup_cipher: ERR_CIPHER_INIT EXIT\n"); 1122 return XLR_SEC_ERR_CIPHER_INIT; 1123 } 1124 1125 *vector |= cipher_vector; 1126 1127 XLR_SEC_CMD_DIAG("xlr_sec_setup_cipher: EXIT vector = %04x\n", *vector); 1128 1129 return XLR_SEC_ERR_NONE; 1130} 1131 1132static 1133xlr_sec_error_t 1134xlr_sec_setup_digest(xlr_sec_io_pt op, 1135 ControlDescriptor_pt ctl_desc, 1136 uint32_t * vector) 1137{ 1138 uint32_t hash_flag = 0; 1139 uint32_t hmac_flag = 0; 1140 uint32_t digest_vector = 0; 1141 1142 XLR_SEC_CMD_DIAG("xlr_sec_setup_digest: ENTER vector = %04x\n", *vector); 1143 1144 switch (op->digest_type) { 1145 case XLR_SEC_DIGEST_TYPE_MD5: 1146 digest_vector |= XLR_SEC_VECTOR_MAC; 1147 SET_FIELD(ctl_desc->instruction, CTL_DSC_HASH, CTL_DSC_HASH_MD5); 1148 break; 1149 case XLR_SEC_DIGEST_TYPE_SHA1: 1150 digest_vector |= XLR_SEC_VECTOR_MAC; 1151 SET_FIELD(ctl_desc->instruction, CTL_DSC_HASH, CTL_DSC_HASH_SHA1); 1152 break; 1153 case XLR_SEC_DIGEST_TYPE_SHA256: 1154 digest_vector |= XLR_SEC_VECTOR_MAC; 1155 SET_FIELD(ctl_desc->instruction, CTL_DSC_HASH, CTL_DSC_HASH_SHA256); 1156 break; 1157 case XLR_SEC_DIGEST_TYPE_SHA384: 1158 digest_vector |= XLR_SEC_VECTOR_MAC; 1159 SET_FIELD(ctl_desc->instruction, CTL_DSC_HASHHI, CTL_DSC_HASH_SHA384 >> 2); 1160 SET_FIELD(ctl_desc->instruction, CTL_DSC_HASH, CTL_DSC_HASH_SHA384); 1161 break; 1162 case XLR_SEC_DIGEST_TYPE_SHA512: 1163 digest_vector |= XLR_SEC_VECTOR_MAC; 1164 SET_FIELD(ctl_desc->instruction, CTL_DSC_HASHHI, CTL_DSC_HASH_SHA512 >> 2); 1165 SET_FIELD(ctl_desc->instruction, CTL_DSC_HASH, CTL_DSC_HASH_SHA512); 1166 break; 1167 case XLR_SEC_DIGEST_TYPE_GCM: 1168 hash_flag = 1; 1169 digest_vector |= XLR_SEC_VECTOR_GCM; 1170 SET_FIELD(ctl_desc->instruction, CTL_DSC_HASHHI, CTL_DSC_HASH_GCM >> 2); 1171 SET_FIELD(ctl_desc->instruction, CTL_DSC_HASH, CTL_DSC_HASH_GCM); 1172 break; 1173 case XLR_SEC_DIGEST_TYPE_KASUMI_F9: 1174 hash_flag = 1; 1175 digest_vector |= XLR_SEC_VECTOR_F9; 1176 SET_FIELD(ctl_desc->instruction, CTL_DSC_HASHHI, CTL_DSC_HASH_KASUMI_F9 >> 2); 1177 SET_FIELD(ctl_desc->instruction, CTL_DSC_HASH, CTL_DSC_HASH_KASUMI_F9); 1178 break; 1179 case XLR_SEC_DIGEST_TYPE_HMAC_MD5: 1180 hmac_flag = 1; 1181 digest_vector |= XLR_SEC_VECTOR_HMAC; 1182 SET_FIELD(ctl_desc->instruction, CTL_DSC_HASH, CTL_DSC_HASH_MD5); 1183 break; 1184 case XLR_SEC_DIGEST_TYPE_HMAC_SHA1: 1185 hmac_flag = 1; 1186 digest_vector |= XLR_SEC_VECTOR_HMAC; 1187 SET_FIELD(ctl_desc->instruction, CTL_DSC_HASH, CTL_DSC_HASH_SHA1); 1188 break; 1189 case XLR_SEC_DIGEST_TYPE_HMAC_SHA256: 1190 hmac_flag = 1; 1191 digest_vector |= XLR_SEC_VECTOR_HMAC; 1192 SET_FIELD(ctl_desc->instruction, CTL_DSC_HASH, CTL_DSC_HASH_SHA256); 1193 break; 1194 case XLR_SEC_DIGEST_TYPE_HMAC_SHA384: 1195 hmac_flag = 1; 1196 digest_vector |= XLR_SEC_VECTOR_HMAC2; 1197 SET_FIELD(ctl_desc->instruction, CTL_DSC_HASHHI, CTL_DSC_HASH_SHA384 >> 2); 1198 SET_FIELD(ctl_desc->instruction, CTL_DSC_HASH, CTL_DSC_HASH_SHA384); 1199 break; 1200 case XLR_SEC_DIGEST_TYPE_HMAC_SHA512: 1201 hmac_flag = 1; 1202 digest_vector |= XLR_SEC_VECTOR_HMAC2; 1203 SET_FIELD(ctl_desc->instruction, CTL_DSC_HASHHI, CTL_DSC_HASH_SHA512 >> 2); 1204 SET_FIELD(ctl_desc->instruction, CTL_DSC_HASH, CTL_DSC_HASH_SHA512); 1205 break; 1206 default: 1207 return XLR_SEC_ERR_DIGEST_TYPE; 1208 } 1209 1210 if (hmac_flag == 1) { 1211 SET_FIELD(ctl_desc->instruction, CTL_DSC_HMAC, CTL_DSC_HMAC_ON); 1212 1213 } 1214 if (hmac_flag || hash_flag) { 1215 switch (op->digest_init) { 1216 case XLR_SEC_DIGEST_INIT_OLDKEY: 1217 SET_FIELD(ctl_desc->instruction, CTL_DSC_IHASH, CTL_DSC_IHASH_OLD); 1218 break; 1219 case XLR_SEC_DIGEST_INIT_NEWKEY: 1220 SET_FIELD(ctl_desc->instruction, CTL_DSC_IHASH, CTL_DSC_IHASH_NEW); 1221 break; 1222 default: 1223 return XLR_SEC_ERR_DIGEST_INIT; 1224 } 1225 } /* hmac_flag */ 1226 *vector |= digest_vector; 1227 1228 XLR_SEC_CMD_DIAG("xlr_sec_setup_digest: EXIT vector = %04x\n", *vector); 1229 return XLR_SEC_ERR_NONE; 1230} 1231 1232static 1233xlr_sec_error_t 1234xlr_sec_setup_cksum(xlr_sec_io_pt op, 1235 ControlDescriptor_pt ctl_desc) 1236{ 1237 switch (op->cksum_type) { 1238 case XLR_SEC_CKSUM_TYPE_NOP: 1239 SET_FIELD(ctl_desc->instruction, CTL_DSC_CKSUM, CTL_DSC_CKSUM_NOP); 1240 return XLR_SEC_ERR_NONE; 1241 case XLR_SEC_CKSUM_TYPE_IP: 1242 SET_FIELD(ctl_desc->instruction, CTL_DSC_CKSUM, CTL_DSC_CKSUM_IP); 1243 break; 1244 default: 1245 return XLR_SEC_ERR_CKSUM_TYPE; 1246 } 1247 1248 return XLR_SEC_ERR_NONE; 1249} 1250 1251 1252static 1253xlr_sec_error_t 1254xlr_sec_control_setup(xlr_sec_io_pt op, 1255 unsigned int flags, 1256 uint64_t * control, 1257 ControlDescriptor_pt ctl_desc, 1258 xlr_sec_drv_user_t * user, 1259 uint32_t vector) 1260{ 1261 uint64_t *hmac_key = NULL; 1262 uint64_t *cipher_key = NULL; 1263 uint64_t *cipher_state = NULL; 1264 uint32_t ctl_size = 0; 1265 uint64_t ctl_addr = 0; 1266 uint32_t cipher_keylen = 0; 1267 uint32_t hmac_keylen = 0; 1268 uint32_t ctl_len; 1269 1270#ifdef SYM_DEBUG 1271 XLR_SEC_CMD_DIAG(" ENTER vector = %04x\n", vector); 1272#endif 1273 1274 switch (vector) { 1275 case XLR_SEC_VECTOR_MAC: 1276 XLR_SEC_CMD_DIAG(" XLR_SEC_VECTOR_MAC \n"); 1277 ctl_size = sizeof(HMAC_t); 1278 break; 1279 case XLR_SEC_VECTOR_HMAC: 1280 XLR_SEC_CMD_DIAG("XLR_SEC_VECTOR_HMAC \n"); 1281 hmac_key = &ctl_desc->cipherHashInfo.infoHMAC.hmacKey0; 1282 hmac_keylen = sizeof(HMAC_t); 1283 ctl_size = sizeof(HMAC_t); 1284 break; 1285 case XLR_SEC_VECTOR_CIPHER_ARC4: 1286 XLR_SEC_CMD_DIAG("XLR_SEC_VECTOR_CIPHER_ARC4\n"); 1287 cipher_key = &ctl_desc->cipherHashInfo.infoARC4.cipherKey0; 1288 cipher_keylen = op->rc4_key_len; 1289 ctl_size = sizeof(ARC4_t); 1290 break; 1291 case XLR_SEC_VECTOR_CIPHER_ARC4__HMAC: 1292 XLR_SEC_CMD_DIAG("XLR_SEC_VECTOR_CIPHER_ARC4__HMAC\n"); 1293 cipher_key = &ctl_desc->cipherHashInfo.infoARC4HMAC.cipherKey0; 1294 hmac_key = &ctl_desc->cipherHashInfo.infoARC4HMAC.hmacKey0; 1295 cipher_keylen = op->rc4_key_len; 1296 hmac_keylen = sizeof(HMAC_t); 1297 ctl_size = sizeof(ARC4HMAC_t); 1298 break; 1299 case XLR_SEC_VECTOR_CIPHER_ARC4__STATE: 1300 XLR_SEC_CMD_DIAG("XLR_SEC_VECTOR_CIPHER_ARC4__STATE\n"); 1301 cipher_key = &ctl_desc->cipherHashInfo.infoARC4State.cipherKey0; 1302 cipher_state = 1303 &ctl_desc->cipherHashInfo.infoARC4State.Arc4SboxData0; 1304 cipher_keylen = op->rc4_key_len; 1305 ctl_size = sizeof(ARC4State_t); 1306 break; 1307 case XLR_SEC_VECTOR_CIPHER_ARC4__HMAC__STATE: 1308 XLR_SEC_CMD_DIAG("XLR_SEC_VECTOR_CIPHER_ARC4__HMAC__STATE\n"); 1309 cipher_key = &ctl_desc->cipherHashInfo.infoARC4StateHMAC.cipherKey0; 1310 cipher_state = 1311 &ctl_desc->cipherHashInfo.infoARC4StateHMAC.Arc4SboxData0; 1312 hmac_key = &ctl_desc->cipherHashInfo.infoARC4StateHMAC.hmacKey0; 1313 cipher_keylen = op->rc4_key_len; 1314 hmac_keylen = sizeof(HMAC_t); 1315 ctl_size = sizeof(ARC4StateHMAC_t); 1316 break; 1317 case XLR_SEC_VECTOR_CIPHER_KASUMI_F8: 1318 XLR_SEC_CMD_DIAG("XLR_SEC_VECTOR_CIPHER_KASUMI_F8\n"); 1319 cipher_key = &ctl_desc->cipherHashInfo.infoKASUMIF8.cipherKey0; 1320 cipher_keylen = XLR_SEC_KASUMI_F8_KEY_LENGTH; 1321 ctl_size = sizeof(KASUMIF8_t); 1322 break; 1323 case XLR_SEC_VECTOR_CIPHER_KASUMI_F8__HMAC: 1324 XLR_SEC_CMD_DIAG("XLR_SEC_VECTOR_CIPHER_KASUMI_F8__HMAC\n"); 1325 cipher_key = &ctl_desc->cipherHashInfo.infoKASUMIF8HMAC.cipherKey0; 1326 cipher_keylen = XLR_SEC_KASUMI_F8_KEY_LENGTH; 1327 hmac_key = &ctl_desc->cipherHashInfo.infoKASUMIF8HMAC.hmacKey0; 1328 hmac_keylen = sizeof(HMAC_t); 1329 ctl_size = sizeof(KASUMIF8HMAC_t); 1330 break; 1331 case XLR_SEC_VECTOR_CIPHER_KASUMI_F8__HMAC2: 1332 XLR_SEC_CMD_DIAG("XLR_SEC_VECTOR_CIPHER_KASUMI_F8__HMAC2\n"); 1333 cipher_key = &ctl_desc->cipherHashInfo.infoKASUMIF8HMAC2.cipherKey0; 1334 cipher_keylen = XLR_SEC_KASUMI_F8_KEY_LENGTH; 1335 hmac_key = &ctl_desc->cipherHashInfo.infoKASUMIF8HMAC2.hmacKey0; 1336 hmac_keylen = sizeof(HMAC2_t); 1337 ctl_size = sizeof(KASUMIF8HMAC2_t); 1338 break; 1339 case XLR_SEC_VECTOR_CIPHER_KASUMI_F8__GCM: 1340 XLR_SEC_CMD_DIAG("XLR_SEC_VECTOR_CIPHER_KASUMI_F8__GCM\n"); 1341 cipher_key = &ctl_desc->cipherHashInfo.infoKASUMIF8GCM.cipherKey0; 1342 cipher_keylen = XLR_SEC_KASUMI_F8_KEY_LENGTH; 1343 hmac_key = &ctl_desc->cipherHashInfo.infoKASUMIF8GCM.GCMH0; 1344 hmac_keylen = sizeof(GCM_t); 1345 ctl_size = sizeof(KASUMIF8GCM_t); 1346 break; 1347 case XLR_SEC_VECTOR_CIPHER_KASUMI_F8__F9: 1348 XLR_SEC_CMD_DIAG("XLR_SEC_VECTOR_CIPHER_KASUMI_F8__F9\n"); 1349 cipher_key = &ctl_desc->cipherHashInfo.infoKASUMIF8F9.cipherKey0; 1350 cipher_keylen = XLR_SEC_KASUMI_F8_KEY_LENGTH; 1351 hmac_key = &ctl_desc->cipherHashInfo.infoKASUMIF8F9.authKey0; 1352 hmac_keylen = sizeof(F9_t); 1353 ctl_size = sizeof(KASUMIF8F9_t); 1354 break; 1355 case XLR_SEC_VECTOR__CIPHER_DES__HMAC__MODE_ECB_CBC: 1356 XLR_SEC_CMD_DIAG(" XLR_SEC_VECTOR__CIPHER_DES__HMAC__MODE_ECB_CBC \n"); 1357 cipher_key = &ctl_desc->cipherHashInfo.infoDESHMAC.cipherKey0; 1358 hmac_key = &ctl_desc->cipherHashInfo.infoDESHMAC.hmacKey0; 1359 hmac_keylen = sizeof(HMAC_t); 1360 cipher_keylen = XLR_SEC_DES_KEY_LENGTH; 1361 ctl_size = sizeof(DESHMAC_t); 1362 break; 1363 case XLR_SEC_VECTOR__CIPHER_DES__MODE_ECB_CBC: 1364 XLR_SEC_CMD_DIAG("XLR_SEC_VECTOR__CIPHER_DES__MODE_ECB_CBC \n"); 1365 cipher_key = &ctl_desc->cipherHashInfo.infoDES.cipherKey0; 1366 cipher_keylen = XLR_SEC_DES_KEY_LENGTH; 1367 ctl_size = sizeof(DES_t); 1368 break; 1369 case XLR_SEC_VECTOR__CIPHER_3DES__HMAC__MODE_ECB_CBC: 1370 XLR_SEC_CMD_DIAG("XLR_SEC_VECTOR__CIPHER_3DES__HMAC__MODE_ECB_CBC \n"); 1371 cipher_key = &ctl_desc->cipherHashInfo.info3DESHMAC.cipherKey0; 1372 hmac_key = &ctl_desc->cipherHashInfo.info3DESHMAC.hmacKey0; 1373 cipher_keylen = XLR_SEC_3DES_KEY_LENGTH; 1374 hmac_keylen = sizeof(HMAC_t); 1375 ctl_size = sizeof(DES3HMAC_t); 1376 break; 1377 case XLR_SEC_VECTOR__CIPHER_3DES__MODE_ECB_CBC: 1378 XLR_SEC_CMD_DIAG("XLR_SEC_VECTOR__CIPHER_3DES__MODE_ECB_CBC \n"); 1379 cipher_key = &ctl_desc->cipherHashInfo.info3DES.cipherKey0; 1380 cipher_keylen = XLR_SEC_3DES_KEY_LENGTH; 1381 ctl_size = sizeof(DES3_t); 1382 break; 1383 case XLR_SEC_VECTOR__CIPHER_AES128__HMAC__MODE_CTR_CFB: 1384 XLR_SEC_CMD_DIAG("XLR_SEC_VECTOR__CIPHER_AES128__HMAC__MODE_CTR_CFB \n"); 1385 cipher_key = &ctl_desc->cipherHashInfo.infoAES128HMAC.cipherKey0; 1386 hmac_key = &ctl_desc->cipherHashInfo.infoAES128HMAC.hmacKey0; 1387 cipher_keylen = XLR_SEC_AES128_KEY_LENGTH; 1388 hmac_keylen = sizeof(HMAC_t); 1389 ctl_size = sizeof(AES128HMAC_t); 1390 break; 1391 case XLR_SEC_VECTOR__CIPHER_AES128__MODE_CTR_CFB: 1392 XLR_SEC_CMD_DIAG("XLR_SEC_VECTOR__CIPHER_AES128__MODE_CTR_CFB \n"); 1393 cipher_key = &ctl_desc->cipherHashInfo.infoAES128.cipherKey0; 1394 cipher_keylen = XLR_SEC_AES128_KEY_LENGTH; 1395 ctl_size = sizeof(AES128_t); 1396 break; 1397 case XLR_SEC_VECTOR__CIPHER_AES128__HMAC__MODE_ECB_CBC_OFB: 1398 XLR_SEC_CMD_DIAG(" XLR_SEC_VECTOR__CIPHER_AES128__HMAC__MODE_ECB_CBC_OFB \n"); 1399 cipher_key = &ctl_desc->cipherHashInfo.infoAES128HMAC.cipherKey0; 1400 hmac_key = &ctl_desc->cipherHashInfo.infoAES128HMAC.hmacKey0; 1401 cipher_keylen = XLR_SEC_AES128_KEY_LENGTH; 1402 hmac_keylen = sizeof(HMAC_t); 1403 ctl_size = sizeof(AES128HMAC_t); 1404 break; 1405 case XLR_SEC_VECTOR__CIPHER_AES128__MODE_ECB_CBC_OFB: 1406 XLR_SEC_CMD_DIAG("XLR_SEC_VECTOR__CIPHER_AES128__MODE_ECB_CBC_OFB \n"); 1407 cipher_key = &ctl_desc->cipherHashInfo.infoAES128.cipherKey0; 1408 cipher_keylen = XLR_SEC_AES128_KEY_LENGTH; 1409 ctl_size = sizeof(AES128_t); 1410 break; 1411 case XLR_SEC_VECTOR__CIPHER_AES128__HMAC__MODE_F8: 1412 XLR_SEC_CMD_DIAG("XLR_SEC_VECTOR__CIPHER_AES128__HMAC__MODE_F8 \n"); 1413 cipher_key = &ctl_desc->cipherHashInfo.infoAES128F8HMAC.cipherKey0; 1414 hmac_key = &ctl_desc->cipherHashInfo.infoAES128F8HMAC.hmacKey0; 1415 cipher_keylen = XLR_SEC_AES128F8_KEY_LENGTH; 1416 hmac_keylen = sizeof(HMAC_t); 1417 ctl_size = sizeof(AES128F8HMAC_t); 1418 break; 1419 case XLR_SEC_VECTOR__CIPHER_AES128__MODE_F8: 1420 XLR_SEC_CMD_DIAG("XLR_SEC_VECTOR__CIPHER_AES128__MODE_F8 \n"); 1421 cipher_key = &ctl_desc->cipherHashInfo.infoAES128F8.cipherKey0; 1422 cipher_keylen = XLR_SEC_AES128F8_KEY_LENGTH; 1423 ctl_size = sizeof(AES128F8_t); 1424 break; 1425 case XLR_SEC_VECTOR__CIPHER_AES192__HMAC__MODE_CTR_CFB: 1426 XLR_SEC_CMD_DIAG("XLR_SEC_VECTOR__CIPHER_AES192__HMAC__MODE_CTR_CFB \n"); 1427 cipher_key = &ctl_desc->cipherHashInfo.infoAES192HMAC.cipherKey0; 1428 hmac_key = &ctl_desc->cipherHashInfo.infoAES192HMAC.hmacKey0; 1429 cipher_keylen = XLR_SEC_AES192_KEY_LENGTH; 1430 hmac_keylen = sizeof(HMAC_t); 1431 ctl_size = sizeof(AES192HMAC_t); 1432 break; 1433 case XLR_SEC_VECTOR__CIPHER_AES192__MODE_CTR_CFB: 1434 XLR_SEC_CMD_DIAG("XLR_SEC_VECTOR__CIPHER_AES192__MODE_CTR_CFB \n"); 1435 cipher_key = &ctl_desc->cipherHashInfo.infoAES192.cipherKey0; 1436 cipher_keylen = XLR_SEC_AES192_KEY_LENGTH; 1437 ctl_size = sizeof(AES192_t); 1438 break; 1439 case XLR_SEC_VECTOR__CIPHER_AES192__HMAC__MODE_ECB_CBC_OFB: 1440 XLR_SEC_CMD_DIAG("XLR_SEC_VECTOR__CIPHER_AES192__HMAC__MODE_ECB_CBC_OFB \n"); 1441 cipher_key = &ctl_desc->cipherHashInfo.infoAES192HMAC.cipherKey0; 1442 hmac_key = &ctl_desc->cipherHashInfo.infoAES192HMAC.hmacKey0; 1443 cipher_keylen = XLR_SEC_AES192_KEY_LENGTH; 1444 hmac_keylen = sizeof(HMAC_t); 1445 ctl_size = sizeof(AES192HMAC_t); 1446 break; 1447 case XLR_SEC_VECTOR__CIPHER_AES192__MODE_ECB_CBC_OFB: 1448 XLR_SEC_CMD_DIAG("XLR_SEC_VECTOR__CIPHER_AES192__MODE_ECB_CBC_OFB \n"); 1449 cipher_key = &ctl_desc->cipherHashInfo.infoAES192.cipherKey0; 1450 cipher_keylen = XLR_SEC_AES192_KEY_LENGTH; 1451 ctl_size = sizeof(AES192_t); 1452 break; 1453 case XLR_SEC_VECTOR__CIPHER_AES192__HMAC__MODE_F8: 1454 XLR_SEC_CMD_DIAG("XLR_SEC_VECTOR__CIPHER_AES192__HMAC__MODE_F8 \n"); 1455 cipher_key = &ctl_desc->cipherHashInfo.infoAES192F8HMAC.cipherKey0; 1456 hmac_key = &ctl_desc->cipherHashInfo.infoAES192F8HMAC.hmacKey0; 1457 cipher_keylen = XLR_SEC_AES192F8_KEY_LENGTH; 1458 hmac_keylen = sizeof(HMAC_t); 1459 ctl_size = sizeof(AES192F8HMAC_t); 1460 break; 1461 case XLR_SEC_VECTOR__CIPHER_AES192__MODE_F8: 1462 XLR_SEC_CMD_DIAG("XLR_SEC_VECTOR__CIPHER_AES192__MODE_F8 \n"); 1463 cipher_key = &ctl_desc->cipherHashInfo.infoAES192F8.cipherKey0; 1464 cipher_keylen = XLR_SEC_AES192F8_KEY_LENGTH; 1465 ctl_size = sizeof(AES192F8_t); 1466 break; 1467 1468 case XLR_SEC_VECTOR__CIPHER_AES256__HMAC__MODE_CTR_CFB: 1469 XLR_SEC_CMD_DIAG("XLR_SEC_VECTOR__CIPHER_AES256__HMAC__MODE_CTR_CFB \n"); 1470 cipher_key = &ctl_desc->cipherHashInfo.infoAES256HMAC.cipherKey0; 1471 hmac_key = &ctl_desc->cipherHashInfo.infoAES256HMAC.hmacKey0; 1472 cipher_keylen = XLR_SEC_AES256_KEY_LENGTH; 1473 hmac_keylen = sizeof(HMAC_t); 1474 ctl_size = sizeof(AES256HMAC_t); 1475 break; 1476 case XLR_SEC_VECTOR__CIPHER_AES256__MODE_CTR_CFB: 1477 XLR_SEC_CMD_DIAG("XLR_SEC_VECTOR__CIPHER_AES256__MODE_CTR_CFB \n"); 1478 cipher_key = &ctl_desc->cipherHashInfo.infoAES256.cipherKey0; 1479 cipher_keylen = XLR_SEC_AES256_KEY_LENGTH; 1480 ctl_size = sizeof(AES256_t); 1481 break; 1482 case XLR_SEC_VECTOR__CIPHER_AES256__HMAC__MODE_ECB_CBC_OFB: 1483 XLR_SEC_CMD_DIAG("XLR_SEC_VECTOR__CIPHER_AES256__HMAC__MODE_ECB_CBC_OFB \n"); 1484 cipher_key = &ctl_desc->cipherHashInfo.infoAES256HMAC.cipherKey0; 1485 hmac_key = &ctl_desc->cipherHashInfo.infoAES256HMAC.hmacKey0; 1486 cipher_keylen = XLR_SEC_AES256_KEY_LENGTH; 1487 hmac_keylen = sizeof(HMAC_t); 1488 ctl_size = sizeof(AES256HMAC_t); 1489 break; 1490 case XLR_SEC_VECTOR__CIPHER_AES256__MODE_ECB_CBC_OFB: 1491 XLR_SEC_CMD_DIAG("XLR_SEC_VECTOR__CIPHER_AES256__MODE_ECB_CBC_OFB \n"); 1492 cipher_key = &ctl_desc->cipherHashInfo.infoAES256.cipherKey0; 1493 cipher_keylen = XLR_SEC_AES256_KEY_LENGTH; 1494 ctl_size = sizeof(AES256_t); 1495 break; 1496 case XLR_SEC_VECTOR__CIPHER_AES256__HMAC__MODE_F8: 1497 XLR_SEC_CMD_DIAG("XLR_SEC_VECTOR__CIPHER_AES256__HMAC__MODE_F8 \n"); 1498 cipher_key = &ctl_desc->cipherHashInfo.infoAES256F8HMAC.cipherKey0; 1499 hmac_key = &ctl_desc->cipherHashInfo.infoAES256F8HMAC.hmacKey0; 1500 cipher_keylen = XLR_SEC_AES256F8_KEY_LENGTH; 1501 hmac_keylen = sizeof(HMAC_t); 1502 ctl_size = sizeof(AES256F8HMAC_t); 1503 break; 1504 case XLR_SEC_VECTOR__CIPHER_AES256__MODE_F8: 1505 XLR_SEC_CMD_DIAG("XLR_SEC_VECTOR__CIPHER_AES256__MODE_F8 \n"); 1506 cipher_key = &ctl_desc->cipherHashInfo.infoAES256F8.cipherKey0; 1507 cipher_keylen = XLR_SEC_AES256F8_KEY_LENGTH; 1508 ctl_size = sizeof(AES256F8_t); 1509 break; 1510 case XLR_SEC_VECTOR_HMAC2: 1511 XLR_SEC_CMD_DIAG("XLR_SEC_VECTOR_HMAC2 \n"); 1512 hmac_key = &ctl_desc->cipherHashInfo.infoHMAC2.hmacKey0; 1513 hmac_keylen = sizeof(HMAC2_t); 1514 ctl_size = sizeof(HMAC2_t); 1515 break; 1516 case XLR_SEC_VECTOR_CIPHER_ARC4__HMAC2: 1517 XLR_SEC_CMD_DIAG("XLR_SEC_VECTOR_CIPHER_ARC4__HMAC2\n"); 1518 cipher_key = &ctl_desc->cipherHashInfo.infoARC4HMAC2.cipherKey0; 1519 hmac_key = &ctl_desc->cipherHashInfo.infoARC4HMAC2.hmacKey0; 1520 cipher_keylen = op->rc4_key_len; 1521 hmac_keylen = sizeof(HMAC2_t); 1522 ctl_size = sizeof(ARC4HMAC2_t); 1523 break; 1524 case XLR_SEC_VECTOR_CIPHER_ARC4__HMAC2__STATE: 1525 XLR_SEC_CMD_DIAG("XLR_SEC_VECTOR_CIPHER_ARC4__HMAC2__STATE\n"); 1526 cipher_key = &ctl_desc->cipherHashInfo.infoARC4StateHMAC2.cipherKey0; 1527 cipher_state = 1528 &ctl_desc->cipherHashInfo.infoARC4StateHMAC2.Arc4SboxData0; 1529 hmac_key = &ctl_desc->cipherHashInfo.infoARC4StateHMAC2.hmacKey0; 1530 cipher_keylen = op->rc4_key_len; 1531 hmac_keylen = sizeof(HMAC2_t); 1532 ctl_size = sizeof(ARC4StateHMAC2_t); 1533 break; 1534 case XLR_SEC_VECTOR__CIPHER_DES__HMAC2__MODE_ECB_CBC: 1535 XLR_SEC_CMD_DIAG(" XLR_SEC_VECTOR__CIPHER_DES__HMAC2__MODE_ECB_CBC \n"); 1536 cipher_key = &ctl_desc->cipherHashInfo.infoDESHMAC2.cipherKey0; 1537 hmac_key = &ctl_desc->cipherHashInfo.infoDESHMAC2.hmacKey0; 1538 hmac_keylen = sizeof(HMAC2_t); 1539 cipher_keylen = XLR_SEC_DES_KEY_LENGTH; 1540 ctl_size = sizeof(DESHMAC2_t); 1541 break; 1542 case XLR_SEC_VECTOR__CIPHER_3DES__HMAC2__MODE_ECB_CBC: 1543 XLR_SEC_CMD_DIAG("XLR_SEC_VECTOR__CIPHER_3DES__HMAC2__MODE_ECB_CBC \n"); 1544 cipher_key = &ctl_desc->cipherHashInfo.info3DESHMAC2.cipherKey0; 1545 hmac_key = &ctl_desc->cipherHashInfo.info3DESHMAC2.hmacKey0; 1546 cipher_keylen = XLR_SEC_3DES_KEY_LENGTH; 1547 hmac_keylen = sizeof(HMAC2_t); 1548 ctl_size = sizeof(DES3HMAC2_t); 1549 break; 1550 case XLR_SEC_VECTOR__CIPHER_AES128__HMAC2__MODE_CTR_CFB: 1551 XLR_SEC_CMD_DIAG("XLR_SEC_VECTOR__CIPHER_AES128__HMAC2__MODE_CTR_CFB \n"); 1552 cipher_key = &ctl_desc->cipherHashInfo.infoAES128HMAC2.cipherKey0; 1553 hmac_key = &ctl_desc->cipherHashInfo.infoAES128HMAC2.hmacKey0; 1554 cipher_keylen = XLR_SEC_AES128_KEY_LENGTH; 1555 hmac_keylen = sizeof(HMAC2_t); 1556 ctl_size = sizeof(AES128HMAC2_t); 1557 break; 1558 case XLR_SEC_VECTOR__CIPHER_AES128__HMAC2__MODE_ECB_CBC_OFB: 1559 XLR_SEC_CMD_DIAG(" XLR_SEC_VECTOR__CIPHER_AES128__HMAC2__MODE_ECB_CBC_OFB \n"); 1560 cipher_key = &ctl_desc->cipherHashInfo.infoAES128HMAC2.cipherKey0; 1561 hmac_key = &ctl_desc->cipherHashInfo.infoAES128HMAC2.hmacKey0; 1562 cipher_keylen = XLR_SEC_AES128_KEY_LENGTH; 1563 hmac_keylen = sizeof(HMAC2_t); 1564 ctl_size = sizeof(AES128HMAC2_t); 1565 break; 1566 case XLR_SEC_VECTOR__CIPHER_AES128__HMAC2__MODE_F8: 1567 XLR_SEC_CMD_DIAG("XLR_SEC_VECTOR__CIPHER_AES128__HMAC2__MODE_F8 \n"); 1568 cipher_key = &ctl_desc->cipherHashInfo.infoAES128F8HMAC2.cipherKey0; 1569 hmac_key = &ctl_desc->cipherHashInfo.infoAES128F8HMAC2.hmacKey0; 1570 cipher_keylen = XLR_SEC_AES128F8_KEY_LENGTH; 1571 hmac_keylen = sizeof(HMAC2_t); 1572 ctl_size = sizeof(AES128F8HMAC2_t); 1573 break; 1574 case XLR_SEC_VECTOR__CIPHER_AES192__HMAC2__MODE_CTR_CFB: 1575 XLR_SEC_CMD_DIAG("XLR_SEC_VECTOR__CIPHER_AES192__HMAC2__MODE_CTR_CFB \n"); 1576 cipher_key = &ctl_desc->cipherHashInfo.infoAES192HMAC2.cipherKey0; 1577 hmac_key = &ctl_desc->cipherHashInfo.infoAES192HMAC2.hmacKey0; 1578 cipher_keylen = XLR_SEC_AES192_KEY_LENGTH; 1579 hmac_keylen = sizeof(HMAC2_t); 1580 ctl_size = sizeof(AES192HMAC2_t); 1581 break; 1582 case XLR_SEC_VECTOR__CIPHER_AES192__HMAC2__MODE_ECB_CBC_OFB: 1583 XLR_SEC_CMD_DIAG("XLR_SEC_VECTOR__CIPHER_AES192__HMAC2__MODE_ECB_CBC_OFB \n"); 1584 cipher_key = &ctl_desc->cipherHashInfo.infoAES192HMAC2.cipherKey0; 1585 hmac_key = &ctl_desc->cipherHashInfo.infoAES192HMAC2.hmacKey0; 1586 cipher_keylen = XLR_SEC_AES192_KEY_LENGTH; 1587 hmac_keylen = sizeof(HMAC2_t); 1588 ctl_size = sizeof(AES192HMAC2_t); 1589 break; 1590 case XLR_SEC_VECTOR__CIPHER_AES192__HMAC2__MODE_F8: 1591 XLR_SEC_CMD_DIAG("XLR_SEC_VECTOR__CIPHER_AES192__HMAC2__MODE_F8 \n"); 1592 cipher_key = &ctl_desc->cipherHashInfo.infoAES192F8HMAC2.cipherKey0; 1593 hmac_key = &ctl_desc->cipherHashInfo.infoAES192F8HMAC2.hmacKey0; 1594 cipher_keylen = XLR_SEC_AES192F8_KEY_LENGTH; 1595 hmac_keylen = sizeof(HMAC2_t); 1596 ctl_size = sizeof(AES192F8HMAC2_t); 1597 break; 1598 case XLR_SEC_VECTOR__CIPHER_AES256__HMAC2__MODE_CTR_CFB: 1599 XLR_SEC_CMD_DIAG("XLR_SEC_VECTOR__CIPHER_AES256__HMAC2__MODE_CTR_CFB \n"); 1600 cipher_key = &ctl_desc->cipherHashInfo.infoAES256HMAC2.cipherKey0; 1601 hmac_key = &ctl_desc->cipherHashInfo.infoAES256HMAC2.hmacKey0; 1602 cipher_keylen = XLR_SEC_AES256_KEY_LENGTH; 1603 hmac_keylen = sizeof(HMAC2_t); 1604 ctl_size = sizeof(AES256HMAC2_t); 1605 break; 1606 case XLR_SEC_VECTOR__CIPHER_AES256__HMAC2__MODE_ECB_CBC_OFB: 1607 XLR_SEC_CMD_DIAG("XLR_SEC_VECTOR__CIPHER_AES256__HMAC2__MODE_ECB_CBC_OFB \n"); 1608 cipher_key = &ctl_desc->cipherHashInfo.infoAES256HMAC2.cipherKey0; 1609 hmac_key = &ctl_desc->cipherHashInfo.infoAES256HMAC2.hmacKey0; 1610 cipher_keylen = XLR_SEC_AES256_KEY_LENGTH; 1611 hmac_keylen = sizeof(HMAC2_t); 1612 ctl_size = sizeof(AES256HMAC2_t); 1613 break; 1614 case XLR_SEC_VECTOR__CIPHER_AES256__HMAC2__MODE_F8: 1615 XLR_SEC_CMD_DIAG("XLR_SEC_VECTOR__CIPHER_AES256__HMAC2__MODE_F8 \n"); 1616 cipher_key = &ctl_desc->cipherHashInfo.infoAES256F8HMAC2.cipherKey0; 1617 hmac_key = &ctl_desc->cipherHashInfo.infoAES256F8HMAC2.hmacKey0; 1618 cipher_keylen = XLR_SEC_AES256F8_KEY_LENGTH; 1619 hmac_keylen = sizeof(HMAC2_t); 1620 ctl_size = sizeof(AES256F8HMAC2_t); 1621 break; 1622 case XLR_SEC_VECTOR_GCM: 1623 XLR_SEC_CMD_DIAG("XLR_SEC_VECTOR_GCM \n"); 1624 hmac_key = &ctl_desc->cipherHashInfo.infoGCM.GCMH0; 1625 hmac_keylen = sizeof(GCM_t); 1626 ctl_size = sizeof(GCM_t); 1627 break; 1628 case XLR_SEC_VECTOR_CIPHER_ARC4__GCM: 1629 XLR_SEC_CMD_DIAG("XLR_SEC_VECTOR_CIPHER_ARC4__GCM\n"); 1630 cipher_key = &ctl_desc->cipherHashInfo.infoARC4GCM.cipherKey0; 1631 hmac_key = &ctl_desc->cipherHashInfo.infoARC4GCM.GCMH0; 1632 cipher_keylen = op->rc4_key_len; 1633 hmac_keylen = sizeof(GCM_t); 1634 ctl_size = sizeof(ARC4GCM_t); 1635 break; 1636 case XLR_SEC_VECTOR_CIPHER_ARC4__GCM__STATE: 1637 XLR_SEC_CMD_DIAG("XLR_SEC_VECTOR_CIPHER_ARC4__GCM__STATE\n"); 1638 cipher_key = &ctl_desc->cipherHashInfo.infoARC4StateGCM.cipherKey0; 1639 cipher_state = 1640 &ctl_desc->cipherHashInfo.infoARC4StateGCM.Arc4SboxData0; 1641 hmac_key = &ctl_desc->cipherHashInfo.infoARC4StateGCM.GCMH0; 1642 cipher_keylen = op->rc4_key_len; 1643 hmac_keylen = sizeof(GCM_t); 1644 ctl_size = sizeof(ARC4StateGCM_t); 1645 break; 1646 case XLR_SEC_VECTOR__CIPHER_DES__GCM__MODE_ECB_CBC: 1647 XLR_SEC_CMD_DIAG(" XLR_SEC_VECTOR__CIPHER_DES__GCM__MODE_ECB_CBC \n"); 1648 cipher_key = &ctl_desc->cipherHashInfo.infoDESGCM.cipherKey0; 1649 hmac_key = &ctl_desc->cipherHashInfo.infoDESGCM.GCMH0; 1650 hmac_keylen = sizeof(GCM_t); 1651 cipher_keylen = XLR_SEC_DES_KEY_LENGTH; 1652 ctl_size = sizeof(DESGCM_t); 1653 break; 1654 case XLR_SEC_VECTOR__CIPHER_3DES__GCM__MODE_ECB_CBC: 1655 XLR_SEC_CMD_DIAG("XLR_SEC_VECTOR__CIPHER_3DES__GCM__MODE_ECB_CBC \n"); 1656 cipher_key = &ctl_desc->cipherHashInfo.info3DESGCM.cipherKey0; 1657 hmac_key = &ctl_desc->cipherHashInfo.info3DESGCM.GCMH0; 1658 cipher_keylen = XLR_SEC_3DES_KEY_LENGTH; 1659 hmac_keylen = sizeof(GCM_t); 1660 ctl_size = sizeof(DES3GCM_t); 1661 break; 1662 case XLR_SEC_VECTOR__CIPHER_AES128__GCM__MODE_CTR_CFB: 1663 XLR_SEC_CMD_DIAG("XLR_SEC_VECTOR__CIPHER_AES128__GCM__MODE_CTR_CFB \n"); 1664 cipher_key = &ctl_desc->cipherHashInfo.infoAES128GCM.cipherKey0; 1665 hmac_key = &ctl_desc->cipherHashInfo.infoAES128GCM.GCMH0; 1666 cipher_keylen = XLR_SEC_AES128_KEY_LENGTH; 1667 hmac_keylen = sizeof(GCM_t); 1668 ctl_size = sizeof(AES128GCM_t); 1669 break; 1670 case XLR_SEC_VECTOR__CIPHER_AES128__GCM__MODE_ECB_CBC_OFB: 1671 XLR_SEC_CMD_DIAG(" XLR_SEC_VECTOR__CIPHER_AES128__GCM__MODE_ECB_CBC_OFB \n"); 1672 cipher_key = &ctl_desc->cipherHashInfo.infoAES128GCM.cipherKey0; 1673 hmac_key = &ctl_desc->cipherHashInfo.infoAES128GCM.GCMH0; 1674 cipher_keylen = XLR_SEC_AES128_KEY_LENGTH; 1675 hmac_keylen = sizeof(GCM_t); 1676 ctl_size = sizeof(AES128GCM_t); 1677 break; 1678 case XLR_SEC_VECTOR__CIPHER_AES128__GCM__MODE_F8: 1679 XLR_SEC_CMD_DIAG("XLR_SEC_VECTOR__CIPHER_AES128__GCM__MODE_F8 \n"); 1680 cipher_key = &ctl_desc->cipherHashInfo.infoAES128F8GCM.cipherKey0; 1681 hmac_key = &ctl_desc->cipherHashInfo.infoAES128F8GCM.GCMH0; 1682 cipher_keylen = XLR_SEC_AES128F8_KEY_LENGTH; 1683 hmac_keylen = sizeof(GCM_t); 1684 ctl_size = sizeof(AES128F8GCM_t); 1685 break; 1686 case XLR_SEC_VECTOR__CIPHER_AES192__GCM__MODE_CTR_CFB: 1687 XLR_SEC_CMD_DIAG("XLR_SEC_VECTOR__CIPHER_AES192__GCM__MODE_CTR_CFB \n"); 1688 cipher_key = &ctl_desc->cipherHashInfo.infoAES192GCM.cipherKey0; 1689 hmac_key = &ctl_desc->cipherHashInfo.infoAES192GCM.GCMH0; 1690 cipher_keylen = XLR_SEC_AES192_KEY_LENGTH; 1691 hmac_keylen = sizeof(GCM_t); 1692 ctl_size = sizeof(AES192GCM_t); 1693 break; 1694 case XLR_SEC_VECTOR__CIPHER_AES192__GCM__MODE_ECB_CBC_OFB: 1695 XLR_SEC_CMD_DIAG("XLR_SEC_VECTOR__CIPHER_AES192__GCM__MODE_ECB_CBC_OFB \n"); 1696 cipher_key = &ctl_desc->cipherHashInfo.infoAES192GCM.cipherKey0; 1697 hmac_key = &ctl_desc->cipherHashInfo.infoAES192GCM.GCMH0; 1698 cipher_keylen = XLR_SEC_AES192_KEY_LENGTH; 1699 hmac_keylen = sizeof(GCM_t); 1700 ctl_size = sizeof(AES192GCM_t); 1701 break; 1702 case XLR_SEC_VECTOR__CIPHER_AES192__GCM__MODE_F8: 1703 XLR_SEC_CMD_DIAG("XLR_SEC_VECTOR__CIPHER_AES192__GCM__MODE_F8 \n"); 1704 cipher_key = &ctl_desc->cipherHashInfo.infoAES192F8GCM.cipherKey0; 1705 hmac_key = &ctl_desc->cipherHashInfo.infoAES192F8GCM.GCMH0; 1706 cipher_keylen = XLR_SEC_AES192F8_KEY_LENGTH; 1707 hmac_keylen = sizeof(GCM_t); 1708 ctl_size = sizeof(AES192F8GCM_t); 1709 break; 1710 case XLR_SEC_VECTOR__CIPHER_AES256__GCM__MODE_CTR_CFB: 1711 XLR_SEC_CMD_DIAG("XLR_SEC_VECTOR__CIPHER_AES256__GCM__MODE_CTR_CFB \n"); 1712 cipher_key = &ctl_desc->cipherHashInfo.infoAES256GCM.cipherKey0; 1713 hmac_key = &ctl_desc->cipherHashInfo.infoAES256GCM.GCMH0; 1714 cipher_keylen = XLR_SEC_AES256_KEY_LENGTH; 1715 hmac_keylen = sizeof(GCM_t); 1716 ctl_size = sizeof(AES256GCM_t); 1717 break; 1718 case XLR_SEC_VECTOR__CIPHER_AES256__GCM__MODE_ECB_CBC_OFB: 1719 XLR_SEC_CMD_DIAG("XLR_SEC_VECTOR__CIPHER_AES256__GCM__MODE_ECB_CBC_OFB \n"); 1720 cipher_key = &ctl_desc->cipherHashInfo.infoAES256GCM.cipherKey0; 1721 hmac_key = &ctl_desc->cipherHashInfo.infoAES256GCM.GCMH0; 1722 cipher_keylen = XLR_SEC_AES256_KEY_LENGTH; 1723 hmac_keylen = sizeof(GCM_t); 1724 ctl_size = sizeof(AES256GCM_t); 1725 break; 1726 case XLR_SEC_VECTOR__CIPHER_AES256__GCM__MODE_F8: 1727 XLR_SEC_CMD_DIAG("XLR_SEC_VECTOR__CIPHER_AES256__GCM__MODE_F8 \n"); 1728 cipher_key = &ctl_desc->cipherHashInfo.infoAES256F8GCM.cipherKey0; 1729 hmac_key = &ctl_desc->cipherHashInfo.infoAES256F8GCM.GCMH0; 1730 cipher_keylen = XLR_SEC_AES256F8_KEY_LENGTH; 1731 hmac_keylen = sizeof(GCM_t); 1732 ctl_size = sizeof(AES256F8GCM_t); 1733 break; 1734 case XLR_SEC_VECTOR_F9: 1735 XLR_SEC_CMD_DIAG("XLR_SEC_VECTOR_F9 \n"); 1736 hmac_key = &ctl_desc->cipherHashInfo.infoF9.authKey0; 1737 hmac_keylen = sizeof(F9_t); 1738 ctl_size = sizeof(F9_t); 1739 break; 1740 case XLR_SEC_VECTOR_CIPHER_ARC4__F9: 1741 XLR_SEC_CMD_DIAG("XLR_SEC_VECTOR_CIPHER_ARC4__F9\n"); 1742 cipher_key = &ctl_desc->cipherHashInfo.infoARC4F9.cipherKey0; 1743 hmac_key = &ctl_desc->cipherHashInfo.infoARC4F9.authKey0; 1744 cipher_keylen = op->rc4_key_len; 1745 hmac_keylen = sizeof(F9_t); 1746 ctl_size = sizeof(ARC4F9_t); 1747 break; 1748 case XLR_SEC_VECTOR_CIPHER_ARC4__F9__STATE: 1749 XLR_SEC_CMD_DIAG("XLR_SEC_VECTOR_CIPHER_ARC4__F9__STATE\n"); 1750 cipher_key = &ctl_desc->cipherHashInfo.infoARC4StateF9.cipherKey0; 1751 cipher_state = 1752 &ctl_desc->cipherHashInfo.infoARC4StateF9.Arc4SboxData0; 1753 hmac_key = &ctl_desc->cipherHashInfo.infoARC4StateF9.authKey0; 1754 cipher_keylen = op->rc4_key_len; 1755 hmac_keylen = sizeof(F9_t); 1756 ctl_size = sizeof(ARC4StateF9_t); 1757 break; 1758 case XLR_SEC_VECTOR__CIPHER_DES__F9__MODE_ECB_CBC: 1759 XLR_SEC_CMD_DIAG(" XLR_SEC_VECTOR__CIPHER_DES__F9__MODE_ECB_CBC \n"); 1760 cipher_key = &ctl_desc->cipherHashInfo.infoDESF9.cipherKey0; 1761 hmac_key = &ctl_desc->cipherHashInfo.infoDESF9.authKey0; 1762 hmac_keylen = sizeof(F9_t); 1763 cipher_keylen = XLR_SEC_DES_KEY_LENGTH; 1764 ctl_size = sizeof(DESF9_t); 1765 break; 1766 case XLR_SEC_VECTOR__CIPHER_3DES__F9__MODE_ECB_CBC: 1767 XLR_SEC_CMD_DIAG("XLR_SEC_VECTOR__CIPHER_3DES__F9__MODE_ECB_CBC \n"); 1768 cipher_key = &ctl_desc->cipherHashInfo.info3DESF9.cipherKey0; 1769 hmac_key = &ctl_desc->cipherHashInfo.info3DESF9.authKey0; 1770 cipher_keylen = XLR_SEC_3DES_KEY_LENGTH; 1771 hmac_keylen = sizeof(F9_t); 1772 ctl_size = sizeof(DES3F9_t); 1773 break; 1774 case XLR_SEC_VECTOR__CIPHER_AES128__F9__MODE_CTR_CFB: 1775 XLR_SEC_CMD_DIAG("XLR_SEC_VECTOR__CIPHER_AES128__F9__MODE_CTR_CFB \n"); 1776 cipher_key = &ctl_desc->cipherHashInfo.infoAES128F9.cipherKey0; 1777 hmac_key = &ctl_desc->cipherHashInfo.infoAES128F9.authKey0; 1778 cipher_keylen = XLR_SEC_AES128_KEY_LENGTH; 1779 hmac_keylen = sizeof(F9_t); 1780 ctl_size = sizeof(AES128F9_t); 1781 break; 1782 case XLR_SEC_VECTOR__CIPHER_AES128__F9__MODE_ECB_CBC_OFB: 1783 XLR_SEC_CMD_DIAG(" XLR_SEC_VECTOR__CIPHER_AES128__F9__MODE_ECB_CBC_OFB \n"); 1784 cipher_key = &ctl_desc->cipherHashInfo.infoAES128F9.cipherKey0; 1785 hmac_key = &ctl_desc->cipherHashInfo.infoAES128F9.authKey0; 1786 cipher_keylen = XLR_SEC_AES128_KEY_LENGTH; 1787 hmac_keylen = sizeof(F9_t); 1788 ctl_size = sizeof(AES128F9_t); 1789 break; 1790 case XLR_SEC_VECTOR__CIPHER_AES128__F9__MODE_F8: 1791 XLR_SEC_CMD_DIAG("XLR_SEC_VECTOR__CIPHER_AES128__F9__MODE_F8 \n"); 1792 cipher_key = &ctl_desc->cipherHashInfo.infoAES128F8F9.cipherKey0; 1793 hmac_key = &ctl_desc->cipherHashInfo.infoAES128F8F9.authKey0; 1794 cipher_keylen = XLR_SEC_AES128F8_KEY_LENGTH; 1795 hmac_keylen = sizeof(F9_t); 1796 ctl_size = sizeof(AES128F8F9_t); 1797 break; 1798 case XLR_SEC_VECTOR__CIPHER_AES192__F9__MODE_CTR_CFB: 1799 XLR_SEC_CMD_DIAG("XLR_SEC_VECTOR__CIPHER_AES192__F9__MODE_CTR_CFB \n"); 1800 cipher_key = &ctl_desc->cipherHashInfo.infoAES192F9.cipherKey0; 1801 hmac_key = &ctl_desc->cipherHashInfo.infoAES192F9.authKey0; 1802 cipher_keylen = XLR_SEC_AES192_KEY_LENGTH; 1803 hmac_keylen = sizeof(F9_t); 1804 ctl_size = sizeof(AES192F9_t); 1805 break; 1806 case XLR_SEC_VECTOR__CIPHER_AES192__F9__MODE_ECB_CBC_OFB: 1807 XLR_SEC_CMD_DIAG("XLR_SEC_VECTOR__CIPHER_AES192__F9__MODE_ECB_CBC_OFB \n"); 1808 cipher_key = &ctl_desc->cipherHashInfo.infoAES192F9.cipherKey0; 1809 hmac_key = &ctl_desc->cipherHashInfo.infoAES192F9.authKey0; 1810 cipher_keylen = XLR_SEC_AES192_KEY_LENGTH; 1811 hmac_keylen = sizeof(F9_t); 1812 ctl_size = sizeof(AES192F9_t); 1813 break; 1814 case XLR_SEC_VECTOR__CIPHER_AES192__F9__MODE_F8: 1815 XLR_SEC_CMD_DIAG("XLR_SEC_VECTOR__CIPHER_AES192__F9__MODE_F8 \n"); 1816 cipher_key = &ctl_desc->cipherHashInfo.infoAES192F8F9.cipherKey0; 1817 hmac_key = &ctl_desc->cipherHashInfo.infoAES192F8F9.authKey0; 1818 cipher_keylen = XLR_SEC_AES192F8_KEY_LENGTH; 1819 hmac_keylen = sizeof(F9_t); 1820 ctl_size = sizeof(AES192F8F9_t); 1821 break; 1822 case XLR_SEC_VECTOR__CIPHER_AES256__F9__MODE_CTR_CFB: 1823 XLR_SEC_CMD_DIAG("XLR_SEC_VECTOR__CIPHER_AES256__F9__MODE_CTR_CFB \n"); 1824 cipher_key = &ctl_desc->cipherHashInfo.infoAES256F9.cipherKey0; 1825 hmac_key = &ctl_desc->cipherHashInfo.infoAES256F9.authKey0; 1826 cipher_keylen = XLR_SEC_AES256_KEY_LENGTH; 1827 hmac_keylen = sizeof(F9_t); 1828 ctl_size = sizeof(AES256F9_t); 1829 break; 1830 case XLR_SEC_VECTOR__CIPHER_AES256__F9__MODE_ECB_CBC_OFB: 1831 XLR_SEC_CMD_DIAG("XLR_SEC_VECTOR__CIPHER_AES256__F9__MODE_ECB_CBC_OFB \n"); 1832 cipher_key = &ctl_desc->cipherHashInfo.infoAES256F9.cipherKey0; 1833 hmac_key = &ctl_desc->cipherHashInfo.infoAES256F9.authKey0; 1834 cipher_keylen = XLR_SEC_AES256_KEY_LENGTH; 1835 hmac_keylen = sizeof(F9_t); 1836 ctl_size = sizeof(AES256F9_t); 1837 break; 1838 case XLR_SEC_VECTOR__CIPHER_AES256__F9__MODE_F8: 1839 XLR_SEC_CMD_DIAG("XLR_SEC_VECTOR__CIPHER_AES256__F9__MODE_F8 \n"); 1840 cipher_key = &ctl_desc->cipherHashInfo.infoAES256F8F9.cipherKey0; 1841 hmac_key = &ctl_desc->cipherHashInfo.infoAES256F8F9.authKey0; 1842 cipher_keylen = XLR_SEC_AES256F8_KEY_LENGTH; 1843 hmac_keylen = sizeof(F9_t); 1844 ctl_size = sizeof(AES256F8F9_t); 1845 break; 1846 1847 default: 1848 XLR_SEC_CMD_DIAG("default \n"); 1849 return XLR_SEC_ERR_CONTROL_VECTOR; 1850 } 1851 1852 if ((cipher_key != NULL) && !(flags & XLR_SEC_SETUP_OP_PRESERVE_CIPHER_KEY)) 1853 memcpy(cipher_key, &op->crypt_key[0], cipher_keylen); 1854 1855 if ((hmac_key != NULL) && !(flags & XLR_SEC_SETUP_OP_PRESERVE_HMAC_KEY)) 1856 memcpy(hmac_key, &op->mac_key[0], hmac_keylen); 1857 if (cipher_state) { 1858 if (op->rc4_loadstate) 1859 memcpy(cipher_state, (void *)(unsigned long)op->rc4_state, 1860 XLR_SEC_MAX_RC4_STATE_SIZE); 1861 if (op->rc4_savestate) 1862 user->aligned_state = (char *)cipher_state; 1863 } 1864 if (flags & XLR_SEC_SETUP_OP_FLIP_3DES_KEY) { 1865 uint64_t temp; 1866 1867 temp = ctl_desc->cipherHashInfo.info3DES.cipherKey0; 1868 ctl_desc->cipherHashInfo.info3DES.cipherKey0 = 1869 ctl_desc->cipherHashInfo.info3DES.cipherKey2; 1870 ctl_desc->cipherHashInfo.info3DES.cipherKey2 = temp; 1871 } 1872 /* 1873 * Control length is the number of control cachelines to be read so 1874 * user needs to round up the control length to closest integer 1875 * multiple of 32 bytes. 1876 */ 1877 ctl_size += sizeof(ctl_desc->instruction); 1878 ctl_len = NUM_CHUNKS(ctl_size, 5); 1879 XLR_SEC_CMD_DIAG("ctl_size in bytes: %u, in cachelines: %u\n", ctl_size, ctl_len); 1880 CLEAR_SET_FIELD(*control, MSG_CMD_CTL_LEN, ctl_len); 1881 1882 ctl_addr = (uint64_t) vtophys(ctl_desc); 1883 CLEAR_SET_FIELD(*control, MSG_CMD_CTL_ADDR, ctl_addr); 1884 1885 XLR_SEC_CMD_DIAG(" xlr_sec_control_setup(): ctl_desc=%p ctl_addr=%llx \n", 1886 ctl_desc, (unsigned long long)ctl_addr); 1887 1888 CLEAR_SET_FIELD(*control, MSG_CMD_CTL_CTL, SEC_SOP); 1889 1890 return XLR_SEC_ERR_NONE; 1891} 1892 1893xlr_sec_error_t 1894xlr_sec_submit_op(symkey_desc_pt desc) 1895{ 1896 struct msgrng_msg send_msg; 1897 1898 int rsp_dest_id, cpu, hard_cpu, hard_thread; 1899 int code, retries; 1900 unsigned long msgrng_flags = 0; 1901 1902 /* threads (0-3) are orthogonal to buckets 0-3 */ 1903 cpu = xlr_cpu_id(); 1904 1905 hard_cpu = cpu >> 2; 1906 hard_thread = cpu & 0x3;/* thread id */ 1907 rsp_dest_id = (hard_cpu << 3) + hard_thread; 1908 1909 desc->op_ctl.cpu = hard_cpu; 1910 desc->op_ctl.flags = 0; /* called from kernel thread */ 1911 1912 XLR_SEC_CMD_DIAG("[%s]:%d: cpu=0x%x hard_cpu=0x%x hard_thrd=0x%x id=0x%x \n", 1913 __FUNCTION__, __LINE__, cpu, hard_cpu, hard_thread, rsp_dest_id); 1914 1915 /* 1916 * Set DestId in Message Control Word. This tells the Security 1917 * Engine which bucket to send the reply to for this CPU 1918 */ 1919 CLEAR_SET_FIELD(desc->control, MSG_CMD_CTL_ID, rsp_dest_id); 1920 CLEAR_SET_FIELD(desc->data, MSG_CMD_CTL_ID, rsp_dest_id); 1921 1922 CLEAR_SET_FIELD(desc->control, MSG_CTL_OP_TYPE, MSG0_CTL_OP_ENGINE_SYMKEY); 1923 CLEAR_SET_FIELD(desc->data, MSG_CTL_OP_TYPE, MSG1_CTL_OP_SYMKEY_PIPE0); 1924 1925 send_msg.msg0 = desc->control | (1ULL << 53); 1926 send_msg.msg1 = desc->data | (1ULL << 53) | (1ULL << 52); 1927 send_msg.msg2 = send_msg.msg3 = 0; 1928 1929 desc->op_ctl.flags = 1; 1930 //in_interrupt(); /* ipsec softirq ? */ 1931 1932 XLR_SEC_CMD_DIAG("[%s]: IN_IRQ=%d msg0=0x%llx msg1=0x%llx \n", 1933 __FUNCTION__, desc->op_ctl.flags, send_msg.msg0, send_msg.msg1); 1934 1935 retries = 100; 1936 while (retries--) { 1937 msgrng_flags = msgrng_access_enable(); 1938 code = message_send(SEC_MSGRING_WORDSIZE, MSGRNG_CODE_SEC, 1939 desc->op_ctl.stn_id, &send_msg); 1940 msgrng_restore(msgrng_flags); 1941 if (code == 0) 1942 break; 1943 } 1944 return (XLR_SEC_ERR_NONE); 1945} 1946 1947symkey_desc_pt 1948xlr_sec_allocate_desc(void *session_ptr) 1949{ 1950 uint64_t addr; 1951 symkey_desc_pt aligned, new; 1952 1953 new = (symkey_desc_pt) malloc(sizeof(symkey_desc_t), 1954 M_DEVBUF, M_NOWAIT | M_ZERO); 1955 1956 if (new == NULL) 1957 return (NULL); 1958 1959 new->ses = session_ptr; 1960 1961 new->user.kern_src = new->user.aligned_src = 1962 (uint8_t *) contigmalloc(256 * 1024 + 1024, 1963 M_DEVBUF, M_NOWAIT | M_ZERO, 1964 0, 0xffffffff, XLR_CACHELINE_SIZE, 0); 1965 1966 if (new->user.kern_src == NULL) { 1967 printf("ERROR - malloc failed for user.kern_src\n"); 1968 return NULL; 1969 } 1970 new->user.aligned_dest = new->user.kern_dest = 1971 (uint8_t *) contigmalloc(257 * 1024, 1972 M_DEVBUF, M_NOWAIT | M_ZERO, 1973 0, 0xffffffff, XLR_CACHELINE_SIZE, 0); 1974 1975 if (new->user.aligned_dest == NULL) { 1976 printf("ERROR - malloc failed for user.aligned_dest\n"); 1977 return NULL; 1978 } 1979 new->next_src_buf = (uint8_t *) contigmalloc(256 * 1024 + 1024, 1980 M_DEVBUF, M_NOWAIT | M_ZERO, 1981 0, 0xffffffff, XLR_CACHELINE_SIZE, 0); 1982 1983 if (new->next_src_buf == NULL) { 1984 printf("ERROR - malloc failed for next_src_buf\n"); 1985 return NULL; 1986 } 1987 new->next_dest_buf = 1988 (uint8_t *) contigmalloc(257 * 1024, 1989 M_DEVBUF, M_NOWAIT | M_ZERO, 1990 0, 0xffffffff, XLR_CACHELINE_SIZE, 0); 1991 1992 if (new->next_dest_buf == NULL) { 1993 printf("ERROR - malloc failed for next_dest_buf\n"); 1994 return NULL; 1995 } 1996 new->user.kern_auth = new->user.user_auth = NULL; 1997 new->user.aligned_auth = new->user.user_auth = NULL; 1998 1999 /* find cacheline alignment */ 2000 aligned = new; 2001 addr = (uint64_t) vtophys(new); 2002 2003 /* save for free */ 2004 aligned->alloc = new; 2005 2006 /* setup common control info */ 2007 aligned->op_ctl.phys_self = addr; 2008 aligned->op_ctl.stn_id = MSGRNG_STNID_SEC0; 2009 aligned->op_ctl.vaddr = (uintptr_t)aligned; 2010 2011 return (aligned); 2012} 2013 2014 2015static void 2016xlr_sec_free_desc(symkey_desc_pt desc) 2017{ 2018 if ((desc == NULL) || (desc->alloc == NULL)) { 2019 printf("%s: NULL descriptor \n", __FUNCTION__); 2020 return; 2021 } 2022 contigfree(desc, sizeof(symkey_desc_t), M_DEVBUF); 2023 return; 2024} 2025 2026void 2027print_buf(char *desc, void *data, int len) 2028{ 2029 uint8_t *dp; 2030 int i; 2031 2032 DPRINT("%s: ", desc); /* newline done in for-loop */ 2033 dp = data; 2034 for (i = 0; i < len; i++, dp++) { 2035 if ((i % 16) == 0) 2036 DPRINT("\n"); 2037 DPRINT(" %c%c", 2038 nib2hex[(((*dp) & 0xf0) >> 4)], 2039 nib2hex[((*dp) & 0x0f)]); 2040 } 2041 DPRINT("\n"); 2042} 2043 2044 2045#ifdef XLR_SEC_CMD_DEBUG 2046static void 2047decode_symkey_desc(symkey_desc_pt desc, uint32_t cfg_vector) 2048{ 2049 2050 unsigned long long word; 2051 2052 /* uint8_t *info; */ 2053 /* int i; */ 2054 2055 DPRINT("MSG - CTL: \n"); 2056 DPRINT("\t CTRL = %lld \n", 2057 GET_FIELD(desc->control, MSG_CMD_CTL_CTL)); 2058 DPRINT("\t CTRL LEN = %lld \n", 2059 GET_FIELD(desc->control, MSG_CMD_CTL_LEN)); 2060 DPRINT("\t CTRL ADDR = %llx \n\n", 2061 GET_FIELD(desc->control, MSG_CMD_CTL_ADDR)); 2062 2063 DPRINT("MSG - DATA: \n"); 2064 DPRINT("\t CTRL = %lld \n", 2065 GET_FIELD(desc->data, MSG_CMD_DATA_CTL)); 2066 DPRINT("\t DATA LEN = %lld \n", 2067 GET_FIELD(desc->data, MSG_CMD_DATA_LEN)); 2068 DPRINT("\t DATA ADDR = %llx \n\n", 2069 GET_FIELD(desc->data, MSG_CMD_DATA_ADDR)); 2070 2071 DPRINT("CONTROL DESCRIPTOR: \n"); 2072 word = desc->ctl_desc.instruction; 2073 DPRINT("\tINSTRUCTION: %llx\n", word); 2074 DPRINT("\t\tOVERRIDE CIPH = %lld \n", GET_FIELD(word, CTL_DSC_OVERRIDECIPHER)); 2075 DPRINT("\t\tARC4 WAIT = %lld \n", GET_FIELD(word, CTL_DSC_ARC4_WAIT4SAVE)); 2076 DPRINT("\t\tARC4 SAVE = %lld \n", GET_FIELD(word, CTL_DSC_ARC4_SAVESTATE)); 2077 DPRINT("\t\tARC4 LOAD = %lld \n", GET_FIELD(word, CTL_DSC_ARC4_LOADSTATE)); 2078 DPRINT("\t\tARC4 KEYLEN = %lld \n", GET_FIELD(word, CTL_DSC_ARC4_KEYLEN)); 2079 DPRINT("\t\tCIPHER = %lld \n", GET_FIELD(word, CTL_DSC_CPHR)); 2080 DPRINT("\t\tCIPHER MODE = %lld \n", GET_FIELD(word, CTL_DSC_MODE)); 2081 DPRINT("\t\tINIT CIPHER = %lld \n", GET_FIELD(word, CTL_DSC_ICPHR)); 2082 DPRINT("\t\tHMAC = %lld \n", GET_FIELD(word, CTL_DSC_HMAC)); 2083 DPRINT("\t\tHASH ALG = %lld \n", GET_FIELD(word, CTL_DSC_HASH) | (GET_FIELD(word, CTL_DSC_HASHHI) << 2)); 2084 DPRINT("\t\tINIT HASH = %lld \n", GET_FIELD(word, CTL_DSC_IHASH)); 2085 DPRINT("\t\tCHKSUM = %lld \n", GET_FIELD(word, CTL_DSC_CKSUM)); 2086 DPRINT("\tCIPHER HASH INFO: \n"); 2087#if 0 2088 info = (uint8_t *) & desc->ctl_desc->cipherHashInfo; 2089 for (i = 0; i < sizeof(CipherHashInfo_t); i++, info++) { 2090 DPRINT(" %02x", *info); 2091 if (i && (i % 16) == 0) 2092 DPRINT("\n"); 2093 } 2094 DPRINT("\n\n"); 2095#endif 2096 2097 switch (cfg_vector) { 2098 case XLR_SEC_VECTOR_CIPHER_ARC4: 2099 DPRINT("VECTOR: XLR_SEC_VECTOR_CIPHER_ARC4 \n"); 2100 print_buf("ARC4 Key", 2101 &desc->ctl_desc.cipherHashInfo.infoARC4.cipherKey0, 2102 GET_FIELD(word, CTL_DSC_ARC4_KEYLEN)); 2103 break; 2104 case XLR_SEC_VECTOR_CIPHER_ARC4__HMAC: 2105 DPRINT("VECTOR: XLR_SEC_VECTOR_CIPHER_ARC4__HMAC \n"); 2106 print_buf("ARC4 Key", 2107 &desc->ctl_desc.cipherHashInfo.infoARC4HMAC.cipherKey0, 2108 GET_FIELD(word, CTL_DSC_ARC4_KEYLEN)); 2109 print_buf("HMAC Key", 2110 &desc->ctl_desc.cipherHashInfo.infoARC4HMAC.hmacKey0, 2111 sizeof(HMAC_t)); 2112 break; 2113 case XLR_SEC_VECTOR_CIPHER_ARC4__STATE: 2114 DPRINT("VECTOR: XLR_SEC_VECTOR_CIPHER_ARC4__STATE \n"); 2115 print_buf("ARC4 Key", 2116 &desc->ctl_desc.cipherHashInfo.infoARC4State.cipherKey0, 2117 GET_FIELD(word, CTL_DSC_ARC4_KEYLEN)); 2118 break; 2119 case XLR_SEC_VECTOR_CIPHER_ARC4__HMAC__STATE: 2120 DPRINT("VECTOR: XLR_SEC_VECTOR_CIPHER_ARC4__HMAC__STATE \n"); 2121 print_buf("ARC4 Key", 2122 &desc->ctl_desc.cipherHashInfo.infoARC4StateHMAC.cipherKey0, 2123 GET_FIELD(word, CTL_DSC_ARC4_KEYLEN)); 2124 print_buf("HMAC Key", 2125 &desc->ctl_desc.cipherHashInfo.infoARC4StateHMAC.hmacKey0, 2126 sizeof(HMAC_t)); 2127 break; 2128 case XLR_SEC_VECTOR_CIPHER_KASUMI_F8: 2129 DPRINT("VECTOR: XLR_SEC_VECTOR_CIPHER_KASUMI_F8 \n"); 2130 print_buf("KASUMI_F8 Key", 2131 &desc->ctl_desc.cipherHashInfo.infoKASUMIF8.cipherKey0, 2132 XLR_SEC_KASUMI_F8_KEY_LENGTH); 2133 break; 2134 case XLR_SEC_VECTOR_CIPHER_KASUMI_F8__HMAC: 2135 DPRINT("XLR_SEC_VECTOR_CIPHER_KASUMI_F8__HMAC\n"); 2136 print_buf("KASUMI_F8 Key", 2137 &desc->ctl_desc.cipherHashInfo.infoKASUMIF8HMAC.cipherKey0, 2138 XLR_SEC_KASUMI_F8_KEY_LENGTH); 2139 print_buf("HMAC Key", 2140 &desc->ctl_desc.cipherHashInfo.infoKASUMIF8HMAC.hmacKey0, 2141 sizeof(HMAC_t)); 2142 break; 2143 case XLR_SEC_VECTOR_CIPHER_KASUMI_F8__HMAC2: 2144 DPRINT("XLR_SEC_VECTOR_CIPHER_KASUMI_F8__HMAC2\n"); 2145 print_buf("KASUMI_F8 Key", 2146 &desc->ctl_desc.cipherHashInfo.infoKASUMIF8HMAC2.cipherKey0, 2147 XLR_SEC_KASUMI_F8_KEY_LENGTH); 2148 print_buf("HMAC2 Key", 2149 &desc->ctl_desc.cipherHashInfo.infoKASUMIF8HMAC2.hmacKey0, 2150 sizeof(HMAC2_t)); 2151 break; 2152 case XLR_SEC_VECTOR_CIPHER_KASUMI_F8__GCM: 2153 DPRINT("XLR_SEC_VECTOR_CIPHER_KASUMI_F8__GCM\n"); 2154 print_buf("KASUMI_F8 Key", 2155 &desc->ctl_desc.cipherHashInfo.infoKASUMIF8GCM.cipherKey0, 2156 XLR_SEC_KASUMI_F8_KEY_LENGTH); 2157 print_buf("GCM Key", 2158 &desc->ctl_desc.cipherHashInfo.infoKASUMIF8GCM.GCMH0, 2159 sizeof(GCM_t)); 2160 break; 2161 case XLR_SEC_VECTOR_CIPHER_KASUMI_F8__F9: 2162 DPRINT("XLR_SEC_VECTOR_CIPHER_KASUMI_F8__F9\n"); 2163 print_buf("KASUMI_F8 Key", 2164 &desc->ctl_desc.cipherHashInfo.infoKASUMIF8F9.cipherKey0, 2165 XLR_SEC_KASUMI_F8_KEY_LENGTH); 2166 print_buf("F9 Key", 2167 &desc->ctl_desc.cipherHashInfo.infoKASUMIF8F9.authKey0, 2168 sizeof(F9_t)); 2169 break; 2170 case XLR_SEC_VECTOR_MAC: 2171 DPRINT("VECTOR: XLR_SEC_VECTOR_MAC \n"); 2172 DPRINT("MAC-ONLY - No Info\n"); 2173 break; 2174 case XLR_SEC_VECTOR_HMAC: 2175 DPRINT("VECTOR: XLR_SEC_VECTOR_HMAC \n"); 2176 print_buf("HMAC Key", 2177 &desc->ctl_desc.cipherHashInfo.infoHMAC.hmacKey0, 2178 sizeof(HMAC_t)); 2179 break; 2180 case XLR_SEC_VECTOR__CIPHER_DES__HMAC__MODE_ECB_CBC: 2181 DPRINT("VECTOR: XLR_SEC_VECTOR__CIPHER_DES__HMAC__MODE_ECB_CBC \n"); 2182 print_buf("CIPHER Key", 2183 &desc->ctl_desc.cipherHashInfo.infoDESHMAC.cipherKey0, 2184 XLR_SEC_DES_KEY_LENGTH); 2185 print_buf("HMAC Key", 2186 &desc->ctl_desc.cipherHashInfo.infoDESHMAC.hmacKey0, 2187 sizeof(HMAC_t)); 2188 break; 2189 case XLR_SEC_VECTOR__CIPHER_DES__MODE_ECB_CBC: 2190 DPRINT("VECTOR: XLR_SEC_VECTOR__CIPHER_DES__MODE_ECB_CBC \n"); 2191 print_buf("CIPHER Key", 2192 &desc->ctl_desc.cipherHashInfo.infoDES.cipherKey0, 2193 XLR_SEC_DES_KEY_LENGTH); 2194 break; 2195 case XLR_SEC_VECTOR__CIPHER_3DES__HMAC__MODE_ECB_CBC: 2196 DPRINT("VECTOR: XLR_SEC_VECTOR__CIPHER_3DES__HMAC__MODE_ECB_CBC \n"); 2197 print_buf("CIPHER Key", 2198 &desc->ctl_desc.cipherHashInfo.info3DESHMAC.cipherKey0, 2199 XLR_SEC_3DES_KEY_LENGTH); 2200 print_buf("HMAC Key", 2201 &desc->ctl_desc.cipherHashInfo.info3DESHMAC.hmacKey0, 2202 sizeof(HMAC_t)); 2203 break; 2204 case XLR_SEC_VECTOR__CIPHER_3DES__MODE_ECB_CBC: 2205 DPRINT("VECTOR: XLR_SEC_VECTOR__CIPHER_3DES__MODE_ECB_CBC \n"); 2206 print_buf("CIPHER Key", 2207 &desc->ctl_desc.cipherHashInfo.info3DES.cipherKey0, 2208 XLR_SEC_3DES_KEY_LENGTH); 2209 break; 2210 case XLR_SEC_VECTOR__CIPHER_AES128__HMAC__MODE_CTR_CFB: 2211 DPRINT("VECTOR: XLR_SEC_VECTOR__CIPHER_AES128__HMAC__MODE_CTR_CFB \n"); 2212 print_buf("CIPHER Key", 2213 &desc->ctl_desc.cipherHashInfo.infoAES128HMAC.cipherKey0, 2214 XLR_SEC_AES128_KEY_LENGTH); 2215 print_buf("HMAC Key", 2216 &desc->ctl_desc.cipherHashInfo.infoAES128HMAC.hmacKey0, 2217 sizeof(HMAC_t)); 2218 break; 2219 case XLR_SEC_VECTOR__CIPHER_AES128__MODE_CTR_CFB: 2220 DPRINT("VECTOR: XLR_SEC_VECTOR__CIPHER_AES128__MODE_CTR_CFB \n"); 2221 print_buf("CIPHER Key", 2222 &desc->ctl_desc.cipherHashInfo.infoAES128.cipherKey0, 2223 XLR_SEC_AES128_KEY_LENGTH); 2224 break; 2225 case XLR_SEC_VECTOR__CIPHER_AES128__HMAC__MODE_ECB_CBC_OFB: 2226 DPRINT("VECTOR: XLR_SEC_VECTOR__CIPHER_AES128__HMAC__MODE_ECB_CBC_OFB\n"); 2227 print_buf("CIPHER Key", 2228 &desc->ctl_desc.cipherHashInfo.infoAES128HMAC.cipherKey0, 2229 XLR_SEC_AES128_KEY_LENGTH); 2230 print_buf("HMAC Key", 2231 &desc->ctl_desc.cipherHashInfo.infoAES128HMAC.hmacKey0, 2232 sizeof(HMAC_t)); 2233 break; 2234 case XLR_SEC_VECTOR__CIPHER_AES128__MODE_ECB_CBC_OFB: 2235 DPRINT("VECTOR: XLR_SEC_VECTOR__CIPHER_AES128__MODE_ECB_CBC_OFB \n"); 2236 print_buf("CIPHER Key", 2237 &desc->ctl_desc.cipherHashInfo.infoAES128.cipherKey0, 2238 XLR_SEC_AES128_KEY_LENGTH); 2239 break; 2240 case XLR_SEC_VECTOR__CIPHER_AES192__HMAC__MODE_CTR_CFB: 2241 DPRINT("VECTOR: XLR_SEC_VECTOR__CIPHER_AES192__HMAC__MODE_CTR_CFB \n"); 2242 print_buf("CIPHER Key", 2243 &desc->ctl_desc.cipherHashInfo.infoAES192HMAC.cipherKey0, 2244 XLR_SEC_AES192_KEY_LENGTH); 2245 print_buf("HMAC Key", 2246 &desc->ctl_desc.cipherHashInfo.infoAES192HMAC.hmacKey0, 2247 sizeof(HMAC_t)); 2248 break; 2249 case XLR_SEC_VECTOR__CIPHER_AES192__MODE_CTR_CFB: 2250 DPRINT("VECTOR: XLR_SEC_VECTOR__CIPHER_AES192__MODE_CTR_CFB \n"); 2251 print_buf("CIPHER Key", 2252 &desc->ctl_desc.cipherHashInfo.infoAES192.cipherKey0, 2253 XLR_SEC_AES192_KEY_LENGTH); 2254 break; 2255 case XLR_SEC_VECTOR__CIPHER_AES192__HMAC__MODE_ECB_CBC_OFB: 2256 DPRINT("VECTOR: XLR_SEC_VECTOR__CIPHER_AES192__HMAC__MODE_ECB_CBC_OFB\n"); 2257 print_buf("CIPHER Key", 2258 &desc->ctl_desc.cipherHashInfo.infoAES192HMAC.cipherKey0, 2259 XLR_SEC_AES192_KEY_LENGTH); 2260 print_buf("HMAC Key", 2261 &desc->ctl_desc.cipherHashInfo.infoAES192HMAC.hmacKey0, 2262 sizeof(HMAC_t)); 2263 break; 2264 case XLR_SEC_VECTOR__CIPHER_AES192__MODE_ECB_CBC_OFB: 2265 DPRINT("VECTOR: XLR_SEC_VECTOR__CIPHER_AES192__MODE_ECB_CBC_OFB \n"); 2266 print_buf("CIPHER Key", 2267 &desc->ctl_desc.cipherHashInfo.infoAES192.cipherKey0, 2268 XLR_SEC_AES192_KEY_LENGTH); 2269 break; 2270 2271 case XLR_SEC_VECTOR__CIPHER_AES256__HMAC__MODE_CTR_CFB: 2272 DPRINT("VECTOR: XLR_SEC_VECTOR__CIPHER_AES256__HMAC__MODE_CTR_CFB \n"); 2273 print_buf("CIPHER Key", 2274 &desc->ctl_desc.cipherHashInfo.infoAES256HMAC.cipherKey0, 2275 XLR_SEC_AES256_KEY_LENGTH); 2276 print_buf("HMAC Key", 2277 &desc->ctl_desc.cipherHashInfo.infoAES256HMAC.hmacKey0, 2278 sizeof(HMAC_t)); 2279 break; 2280 case XLR_SEC_VECTOR__CIPHER_AES256__MODE_CTR_CFB: 2281 DPRINT("VECTOR: XLR_SEC_VECTOR__CIPHER_AES256__MODE_CTR_CFB \n"); 2282 print_buf("CIPHER Key", 2283 &desc->ctl_desc.cipherHashInfo.infoAES256.cipherKey0, 2284 XLR_SEC_AES256_KEY_LENGTH); 2285 break; 2286 case XLR_SEC_VECTOR__CIPHER_AES256__HMAC__MODE_ECB_CBC_OFB: 2287 DPRINT("VECTOR: XLR_SEC_VECTOR__CIPHER_AES256__HMAC__MODE_ECB_CBC_OFB \n"); 2288 print_buf("CIPHER Key", 2289 &desc->ctl_desc.cipherHashInfo.infoAES256HMAC.cipherKey0, 2290 XLR_SEC_AES256_KEY_LENGTH); 2291 print_buf("HMAC Key", 2292 &desc->ctl_desc.cipherHashInfo.infoAES256HMAC.hmacKey0, 2293 sizeof(HMAC_t)); 2294 break; 2295 case XLR_SEC_VECTOR__CIPHER_AES256__MODE_ECB_CBC_OFB: 2296 DPRINT("VECTOR: XLR_SEC_VECTOR__CIPHER_AES256__MODE_ECB_CBC_OFB \n"); 2297 print_buf("CIPHER Key", 2298 &desc->ctl_desc.cipherHashInfo.infoAES256.cipherKey0, 2299 XLR_SEC_AES256_KEY_LENGTH); 2300 break; 2301 case XLR_SEC_VECTOR_CIPHER_ARC4__HMAC2: 2302 DPRINT("VECTOR: XLR_SEC_VECTOR_CIPHER_ARC4__HMAC2 \n"); 2303 print_buf("ARC4 Key", 2304 &desc->ctl_desc.cipherHashInfo.infoARC4HMAC2.cipherKey0, 2305 GET_FIELD(word, CTL_DSC_ARC4_KEYLEN)); 2306 print_buf("HMAC2 Key", 2307 &desc->ctl_desc.cipherHashInfo.infoARC4HMAC2.hmacKey0, 2308 sizeof(HMAC2_t)); 2309 break; 2310 case XLR_SEC_VECTOR_CIPHER_ARC4__HMAC2__STATE: 2311 DPRINT("VECTOR: XLR_SEC_VECTOR_CIPHER_ARC4__HMAC2__STATE \n"); 2312 print_buf("ARC4 Key", 2313 &desc->ctl_desc.cipherHashInfo.infoARC4StateHMAC2.cipherKey0, 2314 GET_FIELD(word, CTL_DSC_ARC4_KEYLEN)); 2315 print_buf("HMAC2 Key", 2316 &desc->ctl_desc.cipherHashInfo.infoARC4StateHMAC2.hmacKey0, 2317 sizeof(HMAC2_t)); 2318 break; 2319 case XLR_SEC_VECTOR_HMAC2: 2320 DPRINT("VECTOR: XLR_SEC_VECTOR_HMAC2 \n"); 2321 print_buf("HMAC2 Key", 2322 &desc->ctl_desc.cipherHashInfo.infoHMAC2.hmacKey0, 2323 sizeof(HMAC2_t)); 2324 break; 2325 case XLR_SEC_VECTOR__CIPHER_DES__HMAC2__MODE_ECB_CBC: 2326 DPRINT("VECTOR: XLR_SEC_VECTOR__CIPHER_DES__HMAC2__MODE_ECB_CBC \n"); 2327 print_buf("CIPHER Key", 2328 &desc->ctl_desc.cipherHashInfo.infoDESHMAC2.cipherKey0, 2329 XLR_SEC_DES_KEY_LENGTH); 2330 print_buf("HMAC2 Key", 2331 &desc->ctl_desc.cipherHashInfo.infoDESHMAC2.hmacKey0, 2332 sizeof(HMAC2_t)); 2333 break; 2334 case XLR_SEC_VECTOR__CIPHER_3DES__HMAC2__MODE_ECB_CBC: 2335 DPRINT("VECTOR: XLR_SEC_VECTOR__CIPHER_3DES__HMAC2__MODE_ECB_CBC \n"); 2336 print_buf("CIPHER Key", 2337 &desc->ctl_desc.cipherHashInfo.info3DESHMAC2.cipherKey0, 2338 XLR_SEC_3DES_KEY_LENGTH); 2339 print_buf("HMAC2 Key", 2340 &desc->ctl_desc.cipherHashInfo.info3DESHMAC2.hmacKey0, 2341 sizeof(HMAC2_t)); 2342 break; 2343 case XLR_SEC_VECTOR__CIPHER_AES128__HMAC2__MODE_CTR_CFB: 2344 DPRINT("VECTOR: XLR_SEC_VECTOR__CIPHER_AES128__HMAC2__MODE_CTR_CFB \n"); 2345 print_buf("CIPHER Key", 2346 &desc->ctl_desc.cipherHashInfo.infoAES128HMAC2.cipherKey0, 2347 XLR_SEC_AES128_KEY_LENGTH); 2348 print_buf("HMAC2 Key", 2349 &desc->ctl_desc.cipherHashInfo.infoAES128HMAC2.hmacKey0, 2350 sizeof(HMAC2_t)); 2351 break; 2352 case XLR_SEC_VECTOR__CIPHER_AES128__HMAC2__MODE_ECB_CBC_OFB: 2353 DPRINT("VECTOR: XLR_SEC_VECTOR__CIPHER_AES128__HMAC2__MODE_ECB_CBC_OFB\n"); 2354 print_buf("CIPHER Key", 2355 &desc->ctl_desc.cipherHashInfo.infoAES128HMAC2.cipherKey0, 2356 XLR_SEC_AES128_KEY_LENGTH); 2357 print_buf("HMAC2 Key", 2358 &desc->ctl_desc.cipherHashInfo.infoAES128HMAC2.hmacKey0, 2359 sizeof(HMAC2_t)); 2360 break; 2361 case XLR_SEC_VECTOR__CIPHER_AES192__HMAC2__MODE_CTR_CFB: 2362 DPRINT("VECTOR: XLR_SEC_VECTOR__CIPHER_AES192__HMAC2__MODE_CTR_CFB \n"); 2363 print_buf("CIPHER Key", 2364 &desc->ctl_desc.cipherHashInfo.infoAES192HMAC2.cipherKey0, 2365 XLR_SEC_AES192_KEY_LENGTH); 2366 print_buf("HMAC2 Key", 2367 &desc->ctl_desc.cipherHashInfo.infoAES192HMAC2.hmacKey0, 2368 sizeof(HMAC2_t)); 2369 break; 2370 case XLR_SEC_VECTOR__CIPHER_AES192__HMAC2__MODE_ECB_CBC_OFB: 2371 DPRINT("VECTOR: XLR_SEC_VECTOR__CIPHER_AES192__HMAC2__MODE_ECB_CBC_OFB\n"); 2372 print_buf("CIPHER Key", 2373 &desc->ctl_desc.cipherHashInfo.infoAES192HMAC2.cipherKey0, 2374 XLR_SEC_AES192_KEY_LENGTH); 2375 print_buf("HMAC2 Key", 2376 &desc->ctl_desc.cipherHashInfo.infoAES192HMAC2.hmacKey0, 2377 sizeof(HMAC2_t)); 2378 break; 2379 case XLR_SEC_VECTOR__CIPHER_AES256__HMAC2__MODE_CTR_CFB: 2380 DPRINT("VECTOR: XLR_SEC_VECTOR__CIPHER_AES256__HMAC2__MODE_CTR_CFB \n"); 2381 print_buf("CIPHER Key", 2382 &desc->ctl_desc.cipherHashInfo.infoAES256HMAC2.cipherKey0, 2383 XLR_SEC_AES256_KEY_LENGTH); 2384 print_buf("HMAC2 Key", 2385 &desc->ctl_desc.cipherHashInfo.infoAES256HMAC2.hmacKey0, 2386 sizeof(HMAC2_t)); 2387 break; 2388 2389 case XLR_SEC_VECTOR__CIPHER_AES256__HMAC2__MODE_ECB_CBC_OFB: 2390 DPRINT("VECTOR: XLR_SEC_VECTOR__CIPHER_AES256__HMAC2__MODE_ECB_CBC_OFB \n"); 2391 print_buf("CIPHER Key", 2392 &desc->ctl_desc.cipherHashInfo.infoAES256HMAC2.cipherKey0, 2393 XLR_SEC_AES256_KEY_LENGTH); 2394 print_buf("HMAC2 Key", 2395 &desc->ctl_desc.cipherHashInfo.infoAES256HMAC2.hmacKey0, 2396 sizeof(HMAC2_t)); 2397 break; 2398 case XLR_SEC_VECTOR_CIPHER_ARC4__GCM: 2399 DPRINT("VECTOR: XLR_SEC_VECTOR_CIPHER_ARC4__GCM \n"); 2400 print_buf("ARC4 Key", 2401 &desc->ctl_desc.cipherHashInfo.infoARC4GCM.cipherKey0, 2402 GET_FIELD(word, CTL_DSC_ARC4_KEYLEN)); 2403 print_buf("GCM Key", 2404 &desc->ctl_desc.cipherHashInfo.infoARC4GCM.GCMH0, 2405 sizeof(GCM_t)); 2406 break; 2407 case XLR_SEC_VECTOR_CIPHER_ARC4__GCM__STATE: 2408 DPRINT("VECTOR: XLR_SEC_VECTOR_CIPHER_ARC4__GCM__STATE \n"); 2409 print_buf("ARC4 Key", 2410 &desc->ctl_desc.cipherHashInfo.infoARC4StateGCM.cipherKey0, 2411 GET_FIELD(word, CTL_DSC_ARC4_KEYLEN)); 2412 print_buf("GCM Key", 2413 &desc->ctl_desc.cipherHashInfo.infoARC4StateGCM.GCMH0, 2414 sizeof(GCM_t)); 2415 break; 2416 case XLR_SEC_VECTOR_GCM: 2417 DPRINT("VECTOR: XLR_SEC_VECTOR_GCM \n"); 2418 print_buf("GCM Key", 2419 &desc->ctl_desc.cipherHashInfo.infoGCM.GCMH0, 2420 sizeof(GCM_t)); 2421 break; 2422 case XLR_SEC_VECTOR__CIPHER_DES__GCM__MODE_ECB_CBC: 2423 DPRINT("VECTOR: XLR_SEC_VECTOR__CIPHER_DES__GCM__MODE_ECB_CBC \n"); 2424 print_buf("CIPHER Key", 2425 &desc->ctl_desc.cipherHashInfo.infoDESGCM.cipherKey0, 2426 XLR_SEC_DES_KEY_LENGTH); 2427 print_buf("GCM Key", 2428 &desc->ctl_desc.cipherHashInfo.infoDESGCM.GCMH0, 2429 sizeof(GCM_t)); 2430 break; 2431 case XLR_SEC_VECTOR__CIPHER_3DES__GCM__MODE_ECB_CBC: 2432 DPRINT("VECTOR: XLR_SEC_VECTOR__CIPHER_3DES__GCM__MODE_ECB_CBC \n"); 2433 print_buf("CIPHER Key", 2434 &desc->ctl_desc.cipherHashInfo.info3DESGCM.cipherKey0, 2435 XLR_SEC_3DES_KEY_LENGTH); 2436 print_buf("GCM Key", 2437 &desc->ctl_desc.cipherHashInfo.info3DESGCM.GCMH0, 2438 sizeof(GCM_t)); 2439 break; 2440 case XLR_SEC_VECTOR__CIPHER_AES128__GCM__MODE_CTR_CFB: 2441 DPRINT("VECTOR: XLR_SEC_VECTOR__CIPHER_AES128__GCM__MODE_CTR_CFB \n"); 2442 print_buf("CIPHER Key", 2443 &desc->ctl_desc.cipherHashInfo.infoAES128GCM.cipherKey0, 2444 XLR_SEC_AES128_KEY_LENGTH); 2445 print_buf("GCM Key", 2446 &desc->ctl_desc.cipherHashInfo.infoAES128GCM.GCMH0, 2447 XLR_SEC_AES128_KEY_LENGTH); 2448 break; 2449 case XLR_SEC_VECTOR__CIPHER_AES128__GCM__MODE_ECB_CBC_OFB: 2450 DPRINT("VECTOR: XLR_SEC_VECTOR__CIPHER_AES128__GCM__MODE_ECB_CBC_OFB\n"); 2451 print_buf("CIPHER Key", 2452 &desc->ctl_desc.cipherHashInfo.infoAES128GCM.cipherKey0, 2453 XLR_SEC_AES128_KEY_LENGTH); 2454 print_buf("GCM Key", 2455 &desc->ctl_desc.cipherHashInfo.infoAES128GCM.GCMH0, 2456 XLR_SEC_AES128_KEY_LENGTH); 2457 break; 2458 case XLR_SEC_VECTOR__CIPHER_AES192__GCM__MODE_CTR_CFB: 2459 DPRINT("VECTOR: XLR_SEC_VECTOR__CIPHER_AES192__GCM__MODE_CTR_CFB \n"); 2460 print_buf("CIPHER Key", 2461 &desc->ctl_desc.cipherHashInfo.infoAES192GCM.cipherKey0, 2462 XLR_SEC_AES192_KEY_LENGTH); 2463 print_buf("GCM Key", 2464 &desc->ctl_desc.cipherHashInfo.infoAES192GCM.GCMH0, 2465 XLR_SEC_AES192_KEY_LENGTH); 2466 break; 2467 case XLR_SEC_VECTOR__CIPHER_AES192__GCM__MODE_ECB_CBC_OFB: 2468 DPRINT("VECTOR: XLR_SEC_VECTOR__CIPHER_AES192__GCM__MODE_ECB_CBC_OFB\n"); 2469 print_buf("CIPHER Key", 2470 &desc->ctl_desc.cipherHashInfo.infoAES192GCM.cipherKey0, 2471 XLR_SEC_AES192_KEY_LENGTH); 2472 print_buf("GCM Key", 2473 &desc->ctl_desc.cipherHashInfo.infoAES192GCM.GCMH0, 2474 XLR_SEC_AES192_KEY_LENGTH); 2475 break; 2476 case XLR_SEC_VECTOR__CIPHER_AES256__GCM__MODE_CTR_CFB: 2477 DPRINT("VECTOR: XLR_SEC_VECTOR__CIPHER_AES256__GCM__MODE_CTR_CFB \n"); 2478 print_buf("CIPHER Key", 2479 &desc->ctl_desc.cipherHashInfo.infoAES256GCM.cipherKey0, 2480 XLR_SEC_AES256_KEY_LENGTH); 2481 print_buf("GCM Key", 2482 &desc->ctl_desc.cipherHashInfo.infoAES256GCM.GCMH0, 2483 XLR_SEC_AES256_KEY_LENGTH); 2484 break; 2485 case XLR_SEC_VECTOR__CIPHER_AES256__GCM__MODE_ECB_CBC_OFB: 2486 DPRINT("VECTOR: XLR_SEC_VECTOR__CIPHER_AES256__GCM__MODE_ECB_CBC_OFB \n"); 2487 print_buf("CIPHER Key", 2488 &desc->ctl_desc.cipherHashInfo.infoAES256GCM.cipherKey0, 2489 XLR_SEC_AES256_KEY_LENGTH); 2490 print_buf("GCM Key", 2491 &desc->ctl_desc.cipherHashInfo.infoAES256GCM.GCMH0, 2492 XLR_SEC_AES256_KEY_LENGTH); 2493 break; 2494 case XLR_SEC_VECTOR_CIPHER_ARC4__F9: 2495 DPRINT("VECTOR: XLR_SEC_VECTOR_CIPHER_ARC4__F9 \n"); 2496 print_buf("ARC4 Key", 2497 &desc->ctl_desc.cipherHashInfo.infoARC4F9.cipherKey0, 2498 GET_FIELD(word, CTL_DSC_ARC4_KEYLEN)); 2499 print_buf("F9 Key", 2500 &desc->ctl_desc.cipherHashInfo.infoARC4F9.authKey0, 2501 sizeof(F9_t)); 2502 break; 2503 case XLR_SEC_VECTOR_CIPHER_ARC4__F9__STATE: 2504 DPRINT("VECTOR: XLR_SEC_VECTOR_CIPHER_ARC4__F9__STATE \n"); 2505 print_buf("ARC4 Key", 2506 &desc->ctl_desc.cipherHashInfo.infoARC4StateF9.cipherKey0, 2507 GET_FIELD(word, CTL_DSC_ARC4_KEYLEN)); 2508 print_buf("F9 Key", 2509 &desc->ctl_desc.cipherHashInfo.infoARC4StateF9.authKey0, 2510 sizeof(F9_t)); 2511 break; 2512 case XLR_SEC_VECTOR_F9: 2513 DPRINT("VECTOR: XLR_SEC_VECTOR_F9 \n"); 2514 print_buf("F9 Key", 2515 &desc->ctl_desc.cipherHashInfo.infoF9.authKey0, 2516 sizeof(F9_t)); 2517 break; 2518 case XLR_SEC_VECTOR__CIPHER_DES__F9__MODE_ECB_CBC: 2519 DPRINT("VECTOR: XLR_SEC_VECTOR__CIPHER_DES__F9__MODE_ECB_CBC \n"); 2520 print_buf("CIPHER Key", 2521 &desc->ctl_desc.cipherHashInfo.infoDESF9.cipherKey0, 2522 XLR_SEC_DES_KEY_LENGTH); 2523 print_buf("F9 Key", 2524 &desc->ctl_desc.cipherHashInfo.infoDESF9.authKey0, 2525 sizeof(F9_t)); 2526 break; 2527 case XLR_SEC_VECTOR__CIPHER_3DES__F9__MODE_ECB_CBC: 2528 DPRINT("VECTOR: XLR_SEC_VECTOR__CIPHER_3DES__F9__MODE_ECB_CBC \n"); 2529 print_buf("CIPHER Key", 2530 &desc->ctl_desc.cipherHashInfo.info3DESF9.cipherKey0, 2531 XLR_SEC_3DES_KEY_LENGTH); 2532 print_buf("F9 Key", 2533 &desc->ctl_desc.cipherHashInfo.info3DESF9.authKey0, 2534 sizeof(F9_t)); 2535 break; 2536 case XLR_SEC_VECTOR__CIPHER_AES128__F9__MODE_CTR_CFB: 2537 DPRINT("VECTOR: XLR_SEC_VECTOR__CIPHER_AES128__F9__MODE_CTR_CFB \n"); 2538 print_buf("CIPHER Key", 2539 &desc->ctl_desc.cipherHashInfo.infoAES128F9.cipherKey0, 2540 XLR_SEC_AES128_KEY_LENGTH); 2541 print_buf("F9 Key", 2542 &desc->ctl_desc.cipherHashInfo.infoAES128F9.authKey0, 2543 sizeof(F9_t)); 2544 break; 2545 case XLR_SEC_VECTOR__CIPHER_AES128__F9__MODE_ECB_CBC_OFB: 2546 DPRINT("VECTOR: XLR_SEC_VECTOR__CIPHER_AES128__F9__MODE_ECB_CBC_OFB\n"); 2547 print_buf("CIPHER Key", 2548 &desc->ctl_desc.cipherHashInfo.infoAES128F9.cipherKey0, 2549 XLR_SEC_AES128_KEY_LENGTH); 2550 print_buf("F9 Key", 2551 &desc->ctl_desc.cipherHashInfo.infoAES128F9.authKey0, 2552 sizeof(F9_t)); 2553 break; 2554 case XLR_SEC_VECTOR__CIPHER_AES192__F9__MODE_CTR_CFB: 2555 DPRINT("VECTOR: XLR_SEC_VECTOR__CIPHER_AES192__F9__MODE_CTR_CFB \n"); 2556 print_buf("CIPHER Key", 2557 &desc->ctl_desc.cipherHashInfo.infoAES192F9.cipherKey0, 2558 XLR_SEC_AES192_KEY_LENGTH); 2559 print_buf("F9 Key", 2560 &desc->ctl_desc.cipherHashInfo.infoAES192F9.authKey0, 2561 sizeof(F9_t)); 2562 break; 2563 case XLR_SEC_VECTOR__CIPHER_AES192__F9__MODE_ECB_CBC_OFB: 2564 DPRINT("VECTOR: XLR_SEC_VECTOR__CIPHER_AES192__F9__MODE_ECB_CBC_OFB\n"); 2565 print_buf("CIPHER Key", 2566 &desc->ctl_desc.cipherHashInfo.infoAES192F9.cipherKey0, 2567 XLR_SEC_AES192_KEY_LENGTH); 2568 print_buf("F9 Key", 2569 &desc->ctl_desc.cipherHashInfo.infoAES192F9.authKey0, 2570 sizeof(F9_t)); 2571 break; 2572 case XLR_SEC_VECTOR__CIPHER_AES256__F9__MODE_CTR_CFB: 2573 DPRINT("VECTOR: XLR_SEC_VECTOR__CIPHER_AES256__F9__MODE_CTR_CFB \n"); 2574 print_buf("CIPHER Key", 2575 &desc->ctl_desc.cipherHashInfo.infoAES256F9.cipherKey0, 2576 XLR_SEC_AES256_KEY_LENGTH); 2577 print_buf("F9 Key", 2578 &desc->ctl_desc.cipherHashInfo.infoAES256F9.authKey0, 2579 sizeof(F9_t)); 2580 break; 2581 case XLR_SEC_VECTOR__CIPHER_AES256__F9__MODE_ECB_CBC_OFB: 2582 DPRINT("VECTOR: XLR_SEC_VECTOR__CIPHER_AES256__F9__MODE_ECB_CBC_OFB \n"); 2583 print_buf("CIPHER Key", 2584 &desc->ctl_desc.cipherHashInfo.infoAES256F9.cipherKey0, 2585 XLR_SEC_AES256_KEY_LENGTH); 2586 print_buf("F9 Key", 2587 &desc->ctl_desc.cipherHashInfo.infoAES256F9.authKey0, 2588 sizeof(F9_t)); 2589 break; 2590 case XLR_SEC_VECTOR__CIPHER_AES128__HMAC__MODE_F8: 2591 DPRINT("VECTOR: XLR_SEC_VECTOR__CIPHER_AES128__HMAC__MODE_F8 \n"); 2592 print_buf("CIPHER Key", 2593 &desc->ctl_desc.cipherHashInfo.infoAES128F8HMAC.cipherKey0, 2594 XLR_SEC_AES128F8_KEY_LENGTH); 2595 print_buf("HMAC Key", 2596 &desc->ctl_desc.cipherHashInfo.infoAES128F8HMAC.hmacKey0, 2597 sizeof(HMAC_t)); 2598 break; 2599 case XLR_SEC_VECTOR__CIPHER_AES128__MODE_F8: 2600 DPRINT("VECTOR: XLR_SEC_VECTOR__CIPHER_AES128__MODE_F8 \n"); 2601 print_buf("CIPHER Key", 2602 &desc->ctl_desc.cipherHashInfo.infoAES128F8.cipherKey0, 2603 XLR_SEC_AES128F8_KEY_LENGTH); 2604 break; 2605 case XLR_SEC_VECTOR__CIPHER_AES192__HMAC__MODE_F8: 2606 DPRINT("VECTOR: XLR_SEC_VECTOR__CIPHER_AES192__HMAC__MODE_F8 \n"); 2607 print_buf("CIPHER Key", 2608 &desc->ctl_desc.cipherHashInfo.infoAES192F8HMAC.cipherKey0, 2609 XLR_SEC_AES192F8_KEY_LENGTH); 2610 print_buf("HMAC Key", 2611 &desc->ctl_desc.cipherHashInfo.infoAES192F8HMAC.hmacKey0, 2612 sizeof(HMAC_t)); 2613 break; 2614 case XLR_SEC_VECTOR__CIPHER_AES192__MODE_F8: 2615 DPRINT("VECTOR: XLR_SEC_VECTOR__CIPHER_AES192__MODE_F8 \n"); 2616 print_buf("CIPHER Key", 2617 &desc->ctl_desc.cipherHashInfo.infoAES192F8.cipherKey0, 2618 XLR_SEC_AES192F8_KEY_LENGTH); 2619 break; 2620 case XLR_SEC_VECTOR__CIPHER_AES256__HMAC__MODE_F8: 2621 DPRINT("VECTOR: XLR_SEC_VECTOR__CIPHER_AES256__HMAC__MODE_F8 \n"); 2622 print_buf("CIPHER Key", 2623 &desc->ctl_desc.cipherHashInfo.infoAES256F8HMAC.cipherKey0, 2624 XLR_SEC_AES256F8_KEY_LENGTH); 2625 print_buf("HMAC Key", 2626 &desc->ctl_desc.cipherHashInfo.infoAES256HMAC.hmacKey0, 2627 sizeof(HMAC_t)); 2628 break; 2629 case XLR_SEC_VECTOR__CIPHER_AES256__MODE_F8: 2630 DPRINT("VECTOR: XLR_SEC_VECTOR__CIPHER_AES256__MODE_F8 \n"); 2631 print_buf("CIPHER Key", 2632 &desc->ctl_desc.cipherHashInfo.infoAES256F8.cipherKey0, 2633 XLR_SEC_AES256F8_KEY_LENGTH); 2634 break; 2635 case XLR_SEC_VECTOR__CIPHER_AES128__HMAC2__MODE_F8: 2636 DPRINT("VECTOR: XLR_SEC_VECTOR__CIPHER_AES128__HMAC2__MODE_F8 \n"); 2637 print_buf("CIPHER Key", 2638 &desc->ctl_desc.cipherHashInfo.infoAES128F8HMAC2.cipherKey0, 2639 XLR_SEC_AES128F8_KEY_LENGTH); 2640 print_buf("HMAC2 Key", 2641 &desc->ctl_desc.cipherHashInfo.infoAES128F8HMAC2.hmacKey0, 2642 sizeof(HMAC2_t)); 2643 break; 2644 case XLR_SEC_VECTOR__CIPHER_AES192__HMAC2__MODE_F8: 2645 DPRINT("VECTOR: XLR_SEC_VECTOR__CIPHER_AES192__HMAC2__MODE_F8 \n"); 2646 print_buf("CIPHER Key", 2647 &desc->ctl_desc.cipherHashInfo.infoAES192F8HMAC2.cipherKey0, 2648 XLR_SEC_AES192F8_KEY_LENGTH); 2649 print_buf("HMAC2 Key", 2650 &desc->ctl_desc.cipherHashInfo.infoAES192F8HMAC2.hmacKey0, 2651 sizeof(HMAC2_t)); 2652 break; 2653 case XLR_SEC_VECTOR__CIPHER_AES256__HMAC2__MODE_F8: 2654 DPRINT("VECTOR: XLR_SEC_VECTOR__CIPHER_AES256__HMAC2__MODE_F8 \n"); 2655 print_buf("CIPHER Key", 2656 &desc->ctl_desc.cipherHashInfo.infoAES256F8HMAC2.cipherKey0, 2657 XLR_SEC_AES256F8_KEY_LENGTH); 2658 print_buf("HMAC2 Key", 2659 &desc->ctl_desc.cipherHashInfo.infoAES256F8HMAC2.hmacKey0, 2660 sizeof(HMAC2_t)); 2661 break; 2662 case XLR_SEC_VECTOR__CIPHER_AES128__GCM__MODE_F8: 2663 DPRINT("VECTOR: XLR_SEC_VECTOR__CIPHER_AES128__GCM__MODE_F8 \n"); 2664 print_buf("CIPHER Key", 2665 &desc->ctl_desc.cipherHashInfo.infoAES128F8GCM.cipherKey0, 2666 XLR_SEC_AES128F8_KEY_LENGTH); 2667 print_buf("GCM Key", 2668 &desc->ctl_desc.cipherHashInfo.infoAES128GCM.GCMH0, 2669 XLR_SEC_AES128_KEY_LENGTH); 2670 break; 2671 case XLR_SEC_VECTOR__CIPHER_AES192__GCM__MODE_F8: 2672 DPRINT("VECTOR: XLR_SEC_VECTOR__CIPHER_AES192__GCM__MODE_F8 \n"); 2673 print_buf("CIPHER Key", 2674 &desc->ctl_desc.cipherHashInfo.infoAES192F8GCM.cipherKey0, 2675 XLR_SEC_AES192_KEY_LENGTH); 2676 print_buf("GCM Key", 2677 &desc->ctl_desc.cipherHashInfo.infoAES192F8GCM.GCMH0, 2678 XLR_SEC_AES192_KEY_LENGTH); 2679 break; 2680 case XLR_SEC_VECTOR__CIPHER_AES256__GCM__MODE_F8: 2681 DPRINT("VECTOR: XLR_SEC_VECTOR__CIPHER_AES256__GCM__MODE_F8 \n"); 2682 print_buf("CIPHER Key", 2683 &desc->ctl_desc.cipherHashInfo.infoAES256F8GCM.cipherKey0, 2684 XLR_SEC_AES256F8_KEY_LENGTH); 2685 print_buf("GCM Key", 2686 &desc->ctl_desc.cipherHashInfo.infoAES256F8GCM.GCMH0, 2687 XLR_SEC_AES256_KEY_LENGTH); 2688 break; 2689 case XLR_SEC_VECTOR__CIPHER_AES128__F9__MODE_F8: 2690 DPRINT("VECTOR: XLR_SEC_VECTOR__CIPHER_AES128__F9__MODE_F8 \n"); 2691 print_buf("CIPHER Key", 2692 &desc->ctl_desc.cipherHashInfo.infoAES128F8F9.cipherKey0, 2693 XLR_SEC_AES128F8_KEY_LENGTH); 2694 print_buf("F9 Key", 2695 &desc->ctl_desc.cipherHashInfo.infoAES128F8F9.authKey0, 2696 sizeof(F9_t)); 2697 break; 2698 case XLR_SEC_VECTOR__CIPHER_AES192__F9__MODE_F8: 2699 DPRINT("VECTOR: XLR_SEC_VECTOR__CIPHER_AES192__F9__MODE_F8 \n"); 2700 print_buf("CIPHER Key", 2701 &desc->ctl_desc.cipherHashInfo.infoAES192F8F9.cipherKey0, 2702 XLR_SEC_AES192F8_KEY_LENGTH); 2703 print_buf("F9 Key", 2704 &desc->ctl_desc.cipherHashInfo.infoAES192F8F9.authKey0, 2705 sizeof(F9_t)); 2706 break; 2707 case XLR_SEC_VECTOR__CIPHER_AES256__F9__MODE_F8: 2708 DPRINT("VECTOR: XLR_SEC_VECTOR__CIPHER_AES256__F9__MODE_F8 \n"); 2709 print_buf("CIPHER Key", 2710 &desc->ctl_desc.cipherHashInfo.infoAES256F8F9.cipherKey0, 2711 XLR_SEC_AES256F8_KEY_LENGTH); 2712 print_buf("F9 Key", 2713 &desc->ctl_desc.cipherHashInfo.infoAES256F8F9.authKey0, 2714 sizeof(F9_t)); 2715 break; 2716 2717 default: 2718 DPRINT("VECTOR: ???? \n"); 2719 DPRINT(">>> WHAT THE HECK !!! <<< \n"); 2720 break; 2721 } 2722 DPRINT("PACKET DESCRIPTOR: \n"); 2723 word = 0; //desc->pkt_desc.srcLengthIVOffUseIVNext; 2724 DPRINT("\tSrcLengthIVOffsetIVNext: %llx\n", word); 2725 DPRINT("\t\tLoad HMAC = %lld \n", 2726 GET_FIELD(word, PKT_DSC_LOADHMACKEY)); 2727 DPRINT("\t\tPad Hash = %lld \n", 2728 GET_FIELD(word, PKT_DSC_PADHASH)); 2729 DPRINT("\t\tHash Byte Count = %lld \n", 2730 GET_FIELD(word, PKT_DSC_HASHBYTES)); 2731 DPRINT("\t\tNext = %lld \n", 2732 GET_FIELD(word, PKT_DSC_NEXT)); 2733 DPRINT("\t\tUse IV = %lld \n", 2734 GET_FIELD(word, PKT_DSC_IV)); 2735 DPRINT("\t\tIV Offset = %lld \n", 2736 GET_FIELD(word, PKT_DSC_IVOFF)); 2737 DPRINT("\t\tPacket Length = %lld \n", 2738 GET_FIELD(word, PKT_DSC_PKTLEN)); 2739 DPRINT("\t\tNLHMAC = %lld \n", GET_FIELD(word, PKT_DSC_NLHMAC)); 2740 DPRINT("\t\tBreak = %lld \n", GET_FIELD(word, PKT_DSC_BREAK)); 2741 DPRINT("\t\tWait = %lld \n", GET_FIELD(word, PKT_DSC_WAIT)); 2742 DPRINT("\t\tSegment Src Addr = %llx \n", 2743 (GET_FIELD(word, PKT_DSC_SEGADDR) << 5) & 0xffffffffffULL); 2744 DPRINT("\t\tSRTCP = %lld \n", GET_FIELD(word, PKT_DSC_SRTCP)); 2745 DPRINT("\t\tGlobal Src Offset = %lld \n", 2746 GET_FIELD(word, PKT_DSC_SEGOFFSET)); 2747 2748 word = 0; //desc->pkt_desc.dstDataSettings; 2749 DPRINT("\tdstDataSettings: %llx \n", word); 2750 DPRINT("\t\tArc4 Byte Count = %lld \n", GET_FIELD(word, 2751 PKT_DSC_ARC4BYTECOUNT)); 2752 DPRINT("\t\tSym Operation = %lld \n", GET_FIELD(word, PKT_DSC_SYM_OP)); 2753 DPRINT("\t\tCipher Offset = %lld \n", GET_FIELD(word, PKT_DSC_CPHROFF)); 2754 DPRINT("\t\tHash Offset = %lld \n", GET_FIELD(word, PKT_DSC_HASHOFF)); 2755 DPRINT("\t\tHash Source = %lld \n", GET_FIELD(word, PKT_DSC_HASHSRC)); 2756 DPRINT("\t\tChecksum Offset = %lld \n", GET_FIELD(word, 2757 PKT_DSC_CKSUMOFF)); 2758 DPRINT("\t\tChecksum Source = %lld \n", GET_FIELD(word, 2759 PKT_DSC_CKSUMSRC)); 2760 DPRINT("\t\tCipher Dest Addr = %llx \n", GET_FIELD(word, 2761 PKT_DSC_CPHR_DST_ADDR)); 2762 DPRINT("\t\tCipher Dest Dword = %lld \n", GET_FIELD(word, 2763 PKT_DSC_CPHR_DST_DWOFFSET)); 2764 DPRINT("\t\tCipher Dest Offset= %lld \n", GET_FIELD(word, 2765 PKT_DSC_CPHR_DST_OFFSET)); 2766 word = 0; //desc->pkt_desc.authDstNonceLow; 2767 DPRINT("\tauthDstNonceLow: %llx \n", word); 2768 DPRINT("\t\tNonce Low 24 = %lld \n", GET_FIELD(word, 2769 PKT_DSC_NONCE_LOW)); 2770 DPRINT("\t\tauthDst = %llx \n", GET_FIELD(word, 2771 PKT_DSC_AUTH_DST_ADDR)); 2772 DPRINT("\t\tCipher Offset High= %lld \n", GET_FIELD(word, 2773 PKT_DSC_CIPH_OFF_HI)); 2774 word = 0; //desc->pkt_desc.ckSumDstNonceHiCFBMaskLLWMask; 2775 DPRINT("\tckSumDstNonceHiCFBMaskLLWMask: %llx \n", word); 2776 DPRINT("\t\tHash Byte off = %lld \n", GET_FIELD(word, PKT_DSC_HASH_BYTE_OFF)); 2777 DPRINT("\t\tPacket Len bytes = %lld \n", GET_FIELD(word, PKT_DSC_PKTLEN_BYTES)); 2778 DPRINT("\t\tLast Long Word Mask = %lld \n", GET_FIELD(word, 2779 PKT_DSC_LASTWORD)); 2780 DPRINT("\t\tCipher Dst Address = %llx \n", GET_FIELD(word, 2781 PKT_DSC_CPHR_DST_ADDR)); 2782 DPRINT("\t\tGlobal Dst Offset = %lld \n", GET_FIELD(word, 2783 PKT_DSC_CPHR_DST_OFFSET)); 2784 2785 DPRINT("CFG_VECTOR = %04x\n", cfg_vector); 2786 DPRINT("\n\n"); 2787} 2788 2789#endif 2790 2791 2792 2793/* This function is called from an interrupt handler */ 2794void 2795xlr_sec_msgring_handler(int bucket, int size, int code, int stid, 2796 struct msgrng_msg *msg, void *data) 2797{ 2798 uint64_t error; 2799 uint64_t addr, sec_eng, sec_pipe; 2800 xlr_sec_io_pt op = NULL; 2801 symkey_desc_pt desc = NULL; 2802 struct xlr_sec_session *ses = NULL; 2803 struct xlr_sec_command *cmd = NULL; 2804 uint32_t flags; 2805 2806 if (code != MSGRNG_CODE_SEC) { 2807 panic("xlr_sec_msgring_handler: bad code = %d," 2808 " expected code = %d\n", 2809 code, MSGRNG_CODE_SEC); 2810 } 2811 if ((stid < MSGRNG_STNID_SEC0) || (stid > MSGRNG_STNID_PK0)) { 2812 panic("xlr_sec_msgring_handler: bad stn id = %d, expect %d - %d\n", 2813 stid, MSGRNG_STNID_SEC0, MSGRNG_STNID_PK0); 2814 } 2815 /* 2816 * The Submit() operation encodes the engine and pipe in these two 2817 * separate fields. This allows use to verify the result type with 2818 * the submitted operation type. 2819 */ 2820 sec_eng = GET_FIELD(msg->msg0, MSG_CTL_OP_TYPE); 2821 sec_pipe = GET_FIELD(msg->msg1, MSG_CTL_OP_TYPE); 2822 2823 error = msg->msg0 >> 40 & 0x1ff; 2824 if (error) 2825 printf("ctrl error = 0x%llx\n", error); 2826 error = msg->msg1 >> 40 & 0x1ff; 2827 if (error) 2828 printf("data error = 0x%llx\n", error); 2829 2830 2831 XLR_SEC_CMD_DIAG("[%s]: eng=%lld pipe=%lld\n", 2832 __FUNCTION__, sec_eng, sec_pipe); 2833 2834 /* Symmetric Key Operation ? */ 2835 if (sec_eng == MSG0_CTL_OP_ENGINE_SYMKEY) { 2836 2837 /* 2838 * The data descriptor address allows us to associate the 2839 * response with the submitted operation. Address is 40-bit 2840 * cacheline aligned address. We need to zero bit 0-4 since 2841 * they are used for the engine and pipe Id. 2842 */ 2843 addr = GET_FIELD(msg->msg1, MSG_RSLT_DATA_DSC_ADDR); 2844 addr = addr & ~((1 << 5) - 1); 2845 if (!addr) { 2846 panic("[%s:STNID_SEC]: NULL symkey addr!\n", __FUNCTION__); 2847 } 2848 2849 /* 2850 * The adddress points to the data descriptor. The operation 2851 * descriptor is defined with the 32-byte cacheline size in 2852 * mind. It allows the code to use this address to 2853 * reference the symkey descriptor. (ref: xlr_sec_desc.h) 2854 */ 2855 addr = addr - sizeof(OperationDescriptor_t); 2856 flags = xlr_enable_kx(); 2857 desc = (symkey_desc_pt)(uintptr_t)xlr_paddr_ld(addr + 2858 offsetof(OperationDescriptor_t, vaddr)); 2859 xlr_restore_kx(flags); 2860 2861 if (!desc) { 2862 printf("\nerror : not getting desc back correctly \n"); 2863 panic("[%s:STNID_SEC]: NULL symkey data descriptor!\n", __FUNCTION__); 2864 } 2865 ses = (struct xlr_sec_session *)desc->ses; 2866 if (!ses) { 2867 printf("\n error : not getting ses back correctly \n"); 2868 panic("[%s:STNID_SEC]: NULL symkey data descriptor!\n", __FUNCTION__); 2869 } 2870 cmd = &ses->cmd; 2871 if (!cmd) { 2872 printf("\n error : not getting cmd back correctly \n"); 2873 panic("[%s:STNID_SEC]: NULL symkey data descriptor!\n", __FUNCTION__); 2874 } 2875 op = &cmd->op; 2876 if (!op) { 2877 printf("\n error : not getting op back correctly \n"); 2878 panic("[%s:STNID_SEC]: NULL symkey data descriptor!\n", __FUNCTION__); 2879 } 2880 XLR_SEC_CMD_DIAG("[%s:STNID_SEC]: addr=0x%llx desc=%p alloc=%p \n", 2881 __FUNCTION__, addr, desc, desc->alloc); 2882 2883 XLR_SEC_CMD_DIAG("[%s:STNID_SEC]: op_ctl=%p phys_self=%llx stn_id=%d \n", 2884 __FUNCTION__, &desc->op_ctl, desc->op_ctl.phys_self, 2885 desc->op_ctl.stn_id); 2886 2887 if (addr != desc->op_ctl.phys_self) { 2888 XLR_SEC_CMD_DIAG("[%s:STNID_SEC]: Control Descriptor fails Self-Verify !\n", 2889 __FUNCTION__); 2890 printf("[%s:STNID_SEC]: Control Descriptor fails Self-Verify !\n", 2891 __FUNCTION__); 2892 printf("[%s:STNID_SEC]: addr=0x%llx desc=%p alloc=%p \n", 2893 __FUNCTION__, (unsigned long long)addr, desc, desc->alloc); 2894 printf("[%s:STNID_SEC]: op_ctl=%p phys_self=%llx stn_id=%d \n", 2895 __FUNCTION__, &desc->op_ctl, (unsigned long long)desc->op_ctl.phys_self, 2896 desc->op_ctl.stn_id); 2897 2898 } 2899 if (desc->op_ctl.stn_id != MSGRNG_STNID_SEC0 && 2900 desc->op_ctl.stn_id != MSGRNG_STNID_SEC1) { 2901 XLR_SEC_CMD_DIAG("[%s:STNID_SEC]: Operation Type Mismatch !\n", 2902 __FUNCTION__); 2903 printf("[%s:STNID_SEC]: Operation Type Mismatch !\n", 2904 __FUNCTION__); 2905 printf("[%s:STNID_SEC]: addr=0x%llx desc=%p alloc=%p \n", 2906 __FUNCTION__, (unsigned long long)addr, desc, desc->alloc); 2907 printf("[%s:STNID_SEC]: op_ctl=%p phys_self=%llx stn_id=%d \n", 2908 __FUNCTION__, &desc->op_ctl, (unsigned long long)desc->op_ctl.phys_self, 2909 desc->op_ctl.stn_id); 2910 } 2911 desc->ctl_result = GET_FIELD(msg->msg0, MSG_RSLT_CTL_INST_ERR); 2912 desc->data_result = GET_FIELD(msg->msg1, MSG_RSLT_DATA_INST_ERR); 2913 2914 XLR_SEC_CMD_DIAG("[%s:STNID_SEC]: cpu=%d ctl_result=0x%llx data_result=%llx\n", 2915 __FUNCTION__, desc->op_ctl.cpu, 2916 desc->ctl_result, desc->data_result); 2917 2918 } 2919#if 0 2920 else if (sec_eng == MSG0_CTL_OP_ENGINE_PUBKEY) { 2921 pubkey_desc_pt desc; 2922 2923 if (sec_pipe != MSG1_CTL_OP_PUBKEY_PIPE0) { 2924 /* response to uc load */ 2925 /* 2926 * XLR_SEC_CMD_DIAG("[%s:STNID_SEC]: ecc cpu=%d 2927 * ctl_result=0x%llx data_result=%llx\n", 2928 * __FUNCTION__, desc->op_ctl.cpu, desc->ctl_result, 2929 * desc->data_result); 2930 */ 2931 return; 2932 } 2933 /* 2934 * The data descriptor address allows us to associate the 2935 * response with the submitted operation. Address is 40-bit 2936 * cacheline aligned address. We need to zero bit 0-4 since 2937 * they are used for the engine and pipe Id. 2938 */ 2939 addr = GET_FIELD(msg->msg0, PUBKEY_RSLT_CTL_SRCADDR); 2940 addr = addr & ~((1 << 5) - 1); 2941 if (!addr) { 2942 panic("[%s:STNID_SEC]: NULL pubkey ctrl desc!\n", __FUNCTION__); 2943 } 2944 /* 2945 * The adddress points to the data descriptor. The operation 2946 * descriptor is defined with the 32-byte cacheline size in 2947 * mind. It allows the code to use this address to 2948 * reference the symkey descriptor. (ref: xlr_sec_desc.h) 2949 */ 2950 addr = addr - sizeof(OperationDescriptor_t); 2951 2952 /* Get pointer to pubkey Descriptor */ 2953 desc = (pubkey_desc_pt) (unsigned long)addr; 2954 if (!desc) { 2955 panic("[%s:STNID_SEC]: NULL pubkey data descriptor!\n", __FUNCTION__); 2956 } 2957 XLR_SEC_CMD_DIAG("[%s:STNID_PK0]: addr=0x%llx desc=%p alloc=%p \n", 2958 __FUNCTION__, addr, desc, desc->alloc); 2959 2960 XLR_SEC_CMD_DIAG("[%s:STNID_PK0]: op_ctl=%p phys_self=%llx stn_id=%d \n", 2961 __FUNCTION__, &desc->op_ctl, desc->op_ctl.phys_self, 2962 desc->op_ctl.stn_id); 2963 2964 if (addr != desc->op_ctl.phys_self) { 2965 XLR_SEC_CMD_DIAG("[%s:STNID_PK0]: Control Descriptor fails Self-Verify !\n", 2966 __FUNCTION__); 2967 } 2968 if (desc->op_ctl.stn_id != msgrng_stnid_pk0) { 2969 XLR_SEC_CMD_DIAG("[%s:STNID_PK0]: Operation Type Mismatch ! \n", 2970 __FUNCTION__); 2971 } 2972 desc->ctl_result = GET_FIELD(msg->msg0, PUBKEY_RSLT_CTL_ERROR); 2973 desc->data_result = GET_FIELD(msg->msg1, PUBKEY_RSLT_DATA_ERROR); 2974 2975 XLR_SEC_CMD_DIAG("[%s:STNID_PK0]: ctl_result=0x%llx data_result=%llx\n", 2976 __FUNCTION__, desc->ctl_result, desc->data_result); 2977 2978 } 2979#endif 2980 else { 2981 printf("[%s]: HANDLER bad id = %d\n", __FUNCTION__, stid); 2982 } 2983#ifdef RMI_SEC_DEBUG 2984 if (ses->multi_frag_flag) { 2985 int i; 2986 char *ptr; 2987 2988 printf("\n RETURNED DATA: \n"); 2989 2990 ptr = (char *)(unsigned long)(desc->user.aligned_dest + cmd->op.cipher_offset); 2991 for (i = 0; i < SEC_MAX_FRAG_LEN; i++) { 2992 printf("%c ", (char)*ptr++); 2993 if ((i % 10) == 0) 2994 printf("\n"); 2995 } 2996 2997 printf("second desc\n"); 2998 ptr = (char *)(unsigned long)(desc->next_dest_buf); 2999 for (i = 0; i < desc->next_src_len; i++) { 3000 printf("%c ", (char)*ptr++); 3001 if ((i % 10) == 0) 3002 printf("\n"); 3003 } 3004 } 3005#endif 3006 3007 /* Copy cipher-data to User-space */ 3008 if (op->cipher_type != XLR_SEC_CIPHER_TYPE_NONE) { 3009 size = op->dest_buf_size; 3010 3011 /* DEBUG -dpk */ 3012 XLR_SEC_CMD_DIAG("cipher: to_addr=%p from_addr=%p size=%d \n", 3013 desc->user.user_dest, desc->user.aligned_dest, size); 3014 3015 if (ses->multi_frag_flag) { 3016 crypto_copyback(cmd->crp->crp_flags, cmd->crp->crp_buf, 0, 3017 SEC_MAX_FRAG_LEN, (caddr_t)(long)desc->user.aligned_dest + op->cipher_offset); 3018 crypto_copyback(cmd->crp->crp_flags, cmd->crp->crp_buf + SEC_MAX_FRAG_LEN, 0, 3019 desc->next_src_len, (caddr_t)(long)desc->next_dest_buf); 3020 crypto_done(cmd->crp); 3021 } else { 3022 crypto_copyback(cmd->crp->crp_flags, cmd->crp->crp_buf, 0, 3023 cmd->op.dest_buf_size, (caddr_t)(long)desc->user.aligned_dest + op->cipher_offset); 3024 crypto_done(cmd->crp); 3025 } 3026 3027 } 3028 3029 /* Copy digest to User-space */ 3030 if (op->digest_type != XLR_SEC_DIGEST_TYPE_NONE) { 3031 int offset = 0; 3032 3033 switch (op->digest_type) { 3034 case XLR_SEC_DIGEST_TYPE_MD5: 3035 size = XLR_SEC_MD5_LENGTH; 3036 break; 3037 case XLR_SEC_DIGEST_TYPE_SHA1: 3038 size = XLR_SEC_SHA1_LENGTH; 3039 break; 3040 case XLR_SEC_DIGEST_TYPE_SHA256: 3041 size = XLR_SEC_SHA256_LENGTH; 3042 break; 3043 case XLR_SEC_DIGEST_TYPE_SHA384: 3044 size = XLR_SEC_SHA384_LENGTH; 3045 break; 3046 case XLR_SEC_DIGEST_TYPE_SHA512: 3047 size = XLR_SEC_SHA512_LENGTH; 3048 break; 3049 case XLR_SEC_DIGEST_TYPE_GCM: 3050 size = XLR_SEC_GCM_LENGTH; 3051 break; 3052 case XLR_SEC_DIGEST_TYPE_KASUMI_F9: 3053 offset = 4; 3054 size = XLR_SEC_KASUMI_F9_RESULT_LENGTH; 3055 break; 3056 default: 3057 size = 0; 3058 } 3059 3060 XLR_SEC_CMD_DIAG("digest: to_addr=%p from_addr=%p size=%d \n", 3061 desc->user.user_auth, desc->user.aligned_auth, size); 3062 memcpy(desc->user.user_auth, desc->user.aligned_auth + offset, size); 3063 op->auth_dest = (uint64_t) (unsigned long)desc->user.user_auth; 3064 } 3065 if (op->cipher_type == XLR_SEC_CIPHER_TYPE_ARC4 && 3066 op->rc4_savestate) { 3067 size = XLR_SEC_MAX_RC4_STATE_SIZE; 3068 3069 XLR_SEC_CMD_DIAG("state: to_addr=%p from_addr=%p size=%d \n", 3070 desc->user.user_state, desc->user.aligned_state, size); 3071 op->rc4_state = (uint64_t) (unsigned long)desc->user.user_state; 3072 } 3073 return; 3074} 3075