1 /* 2 * This file is part of the Chelsio T6 Crypto driver for Linux. 3 * 4 * Copyright (c) 2003-2016 Chelsio Communications, Inc. All rights reserved. 5 * 6 * This software is available to you under a choice of one of two 7 * licenses. You may choose to be licensed under the terms of the GNU 8 * General Public License (GPL) Version 2, available from the file 9 * COPYING in the main directory of this source tree, or the 10 * OpenIB.org BSD license below: 11 * 12 * Redistribution and use in source and binary forms, with or 13 * without modification, are permitted provided that the following 14 * conditions are met: 15 * 16 * - Redistributions of source code must retain the above 17 * copyright notice, this list of conditions and the following 18 * disclaimer. 19 * 20 * - Redistributions in binary form must reproduce the above 21 * copyright notice, this list of conditions and the following 22 * disclaimer in the documentation and/or other materials 23 * provided with the distribution. 24 * 25 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, 26 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF 27 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND 28 * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS 29 * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN 30 * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN 31 * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE 32 * SOFTWARE. 33 * 34 */ 35 36 #ifndef __CHCR_ALGO_H__ 37 #define __CHCR_ALGO_H__ 38 39 /* Crypto key context */ 40 #define KEY_CONTEXT_CTX_LEN_S 24 41 #define KEY_CONTEXT_CTX_LEN_M 0xff 42 #define KEY_CONTEXT_CTX_LEN_V(x) ((x) << KEY_CONTEXT_CTX_LEN_S) 43 #define KEY_CONTEXT_CTX_LEN_G(x) \ 44 (((x) >> KEY_CONTEXT_CTX_LEN_S) & KEY_CONTEXT_CTX_LEN_M) 45 46 #define KEY_CONTEXT_DUAL_CK_S 12 47 #define KEY_CONTEXT_DUAL_CK_M 0x1 48 #define KEY_CONTEXT_DUAL_CK_V(x) ((x) << KEY_CONTEXT_DUAL_CK_S) 49 #define KEY_CONTEXT_DUAL_CK_G(x) \ 50 (((x) >> KEY_CONTEXT_DUAL_CK_S) & KEY_CONTEXT_DUAL_CK_M) 51 #define KEY_CONTEXT_DUAL_CK_F KEY_CONTEXT_DUAL_CK_V(1U) 52 53 #define KEY_CONTEXT_SALT_PRESENT_S 10 54 #define KEY_CONTEXT_SALT_PRESENT_M 0x1 55 #define KEY_CONTEXT_SALT_PRESENT_V(x) ((x) << KEY_CONTEXT_SALT_PRESENT_S) 56 #define KEY_CONTEXT_SALT_PRESENT_G(x) \ 57 (((x) >> KEY_CONTEXT_SALT_PRESENT_S) & \ 58 KEY_CONTEXT_SALT_PRESENT_M) 59 #define KEY_CONTEXT_SALT_PRESENT_F KEY_CONTEXT_SALT_PRESENT_V(1U) 60 61 #define KEY_CONTEXT_VALID_S 0 62 #define KEY_CONTEXT_VALID_M 0x1 63 #define KEY_CONTEXT_VALID_V(x) ((x) << KEY_CONTEXT_VALID_S) 64 #define KEY_CONTEXT_VALID_G(x) \ 65 (((x) >> KEY_CONTEXT_VALID_S) & \ 66 KEY_CONTEXT_VALID_M) 67 #define KEY_CONTEXT_VALID_F KEY_CONTEXT_VALID_V(1U) 68 69 #define KEY_CONTEXT_CK_SIZE_S 6 70 #define KEY_CONTEXT_CK_SIZE_M 0xf 71 #define KEY_CONTEXT_CK_SIZE_V(x) ((x) << KEY_CONTEXT_CK_SIZE_S) 72 #define KEY_CONTEXT_CK_SIZE_G(x) \ 73 (((x) >> KEY_CONTEXT_CK_SIZE_S) & KEY_CONTEXT_CK_SIZE_M) 74 75 #define KEY_CONTEXT_MK_SIZE_S 2 76 #define KEY_CONTEXT_MK_SIZE_M 0xf 77 #define KEY_CONTEXT_MK_SIZE_V(x) ((x) << KEY_CONTEXT_MK_SIZE_S) 78 #define KEY_CONTEXT_MK_SIZE_G(x) \ 79 (((x) >> KEY_CONTEXT_MK_SIZE_S) & KEY_CONTEXT_MK_SIZE_M) 80 81 #define KEY_CONTEXT_OPAD_PRESENT_S 11 82 #define KEY_CONTEXT_OPAD_PRESENT_M 0x1 83 #define KEY_CONTEXT_OPAD_PRESENT_V(x) ((x) << KEY_CONTEXT_OPAD_PRESENT_S) 84 #define KEY_CONTEXT_OPAD_PRESENT_G(x) \ 85 (((x) >> KEY_CONTEXT_OPAD_PRESENT_S) & \ 86 KEY_CONTEXT_OPAD_PRESENT_M) 87 #define KEY_CONTEXT_OPAD_PRESENT_F KEY_CONTEXT_OPAD_PRESENT_V(1U) 88 89 #define CHCR_HASH_MAX_DIGEST_SIZE 64 90 #define CHCR_MAX_SHA_DIGEST_SIZE 64 91 92 #define IPSEC_TRUNCATED_ICV_SIZE 12 93 #define TLS_TRUNCATED_HMAC_SIZE 10 94 #define CBCMAC_DIGEST_SIZE 16 95 #define MAX_HASH_NAME 20 96 97 #define SHA1_INIT_STATE_5X4B 5 98 #define SHA256_INIT_STATE_8X4B 8 99 #define SHA512_INIT_STATE_8X8B 8 100 #define SHA1_INIT_STATE SHA1_INIT_STATE_5X4B 101 #define SHA224_INIT_STATE SHA256_INIT_STATE_8X4B 102 #define SHA256_INIT_STATE SHA256_INIT_STATE_8X4B 103 #define SHA384_INIT_STATE SHA512_INIT_STATE_8X8B 104 #define SHA512_INIT_STATE SHA512_INIT_STATE_8X8B 105 106 #define DUMMY_BYTES 16 107 108 #define IPAD_DATA 0x36363636 109 #define OPAD_DATA 0x5c5c5c5c 110 111 #define TRANSHDR_SIZE(alignedkctx_len)\ 112 (sizeof(struct ulptx_idata) +\ 113 sizeof(struct ulp_txpkt) +\ 114 sizeof(struct fw_crypto_lookaside_wr) +\ 115 sizeof(struct cpl_tx_sec_pdu) +\ 116 (alignedkctx_len)) 117 #define CIPHER_TRANSHDR_SIZE(alignedkctx_len, sge_pairs) \ 118 (TRANSHDR_SIZE(alignedkctx_len) + sge_pairs +\ 119 sizeof(struct cpl_rx_phys_dsgl)) 120 #define HASH_TRANSHDR_SIZE(alignedkctx_len)\ 121 (TRANSHDR_SIZE(alignedkctx_len) + DUMMY_BYTES) 122 123 #define SEC_CPL_OFFSET (sizeof(struct fw_crypto_lookaside_wr) + \ 124 sizeof(struct ulp_txpkt) + \ 125 sizeof(struct ulptx_idata)) 126 127 #define FILL_SEC_CPL_OP_IVINSR(id, len, hldr, ofst) \ 128 htonl( \ 129 CPL_TX_SEC_PDU_OPCODE_V(CPL_TX_SEC_PDU) | \ 130 CPL_TX_SEC_PDU_RXCHID_V((id)) | \ 131 CPL_TX_SEC_PDU_ACKFOLLOWS_V(0) | \ 132 CPL_TX_SEC_PDU_ULPTXLPBK_V(1) | \ 133 CPL_TX_SEC_PDU_CPLLEN_V((len)) | \ 134 CPL_TX_SEC_PDU_PLACEHOLDER_V((hldr)) | \ 135 CPL_TX_SEC_PDU_IVINSRTOFST_V((ofst))) 136 137 #define FILL_SEC_CPL_CIPHERSTOP_HI(a_start, a_stop, c_start, c_stop_hi) \ 138 htonl( \ 139 CPL_TX_SEC_PDU_AADSTART_V((a_start)) | \ 140 CPL_TX_SEC_PDU_AADSTOP_V((a_stop)) | \ 141 CPL_TX_SEC_PDU_CIPHERSTART_V((c_start)) | \ 142 CPL_TX_SEC_PDU_CIPHERSTOP_HI_V((c_stop_hi))) 143 144 #define FILL_SEC_CPL_AUTHINSERT(c_stop_lo, a_start, a_stop, a_inst) \ 145 htonl( \ 146 CPL_TX_SEC_PDU_CIPHERSTOP_LO_V((c_stop_lo)) | \ 147 CPL_TX_SEC_PDU_AUTHSTART_V((a_start)) | \ 148 CPL_TX_SEC_PDU_AUTHSTOP_V((a_stop)) | \ 149 CPL_TX_SEC_PDU_AUTHINSERT_V((a_inst))) 150 151 #define FILL_SEC_CPL_SCMD0_SEQNO(ctrl, seq, cmode, amode, opad, size, nivs) \ 152 htonl( \ 153 SCMD_SEQ_NO_CTRL_V(0) | \ 154 SCMD_STATUS_PRESENT_V(0) | \ 155 SCMD_PROTO_VERSION_V(CHCR_SCMD_PROTO_VERSION_GENERIC) | \ 156 SCMD_ENC_DEC_CTRL_V((ctrl)) | \ 157 SCMD_CIPH_AUTH_SEQ_CTRL_V((seq)) | \ 158 SCMD_CIPH_MODE_V((cmode)) | \ 159 SCMD_AUTH_MODE_V((amode)) | \ 160 SCMD_HMAC_CTRL_V((opad)) | \ 161 SCMD_IV_SIZE_V((size)) | \ 162 SCMD_NUM_IVS_V((nivs))) 163 164 #define FILL_SEC_CPL_IVGEN_HDRLEN(last, more, ctx_in, mac, ivdrop, len) htonl( \ 165 SCMD_ENB_DBGID_V(0) | \ 166 SCMD_IV_GEN_CTRL_V(0) | \ 167 SCMD_LAST_FRAG_V((last)) | \ 168 SCMD_MORE_FRAGS_V((more)) | \ 169 SCMD_TLS_COMPPDU_V(0) | \ 170 SCMD_KEY_CTX_INLINE_V((ctx_in)) | \ 171 SCMD_TLS_FRAG_ENABLE_V(0) | \ 172 SCMD_MAC_ONLY_V((mac)) | \ 173 SCMD_AADIVDROP_V((ivdrop)) | \ 174 SCMD_HDR_LEN_V((len))) 175 176 #define FILL_KEY_CTX_HDR(ck_size, mk_size, d_ck, opad, ctx_len) \ 177 htonl(KEY_CONTEXT_VALID_V(1) | \ 178 KEY_CONTEXT_CK_SIZE_V((ck_size)) | \ 179 KEY_CONTEXT_MK_SIZE_V(mk_size) | \ 180 KEY_CONTEXT_DUAL_CK_V((d_ck)) | \ 181 KEY_CONTEXT_OPAD_PRESENT_V((opad)) | \ 182 KEY_CONTEXT_SALT_PRESENT_V(1) | \ 183 KEY_CONTEXT_CTX_LEN_V((ctx_len))) 184 185 #define FILL_WR_OP_CCTX_SIZE(len, ctx_len) \ 186 htonl( \ 187 FW_CRYPTO_LOOKASIDE_WR_OPCODE_V( \ 188 FW_CRYPTO_LOOKASIDE_WR) | \ 189 FW_CRYPTO_LOOKASIDE_WR_COMPL_V(0) | \ 190 FW_CRYPTO_LOOKASIDE_WR_IMM_LEN_V((len)) | \ 191 FW_CRYPTO_LOOKASIDE_WR_CCTX_LOC_V(1) | \ 192 FW_CRYPTO_LOOKASIDE_WR_CCTX_SIZE_V((ctx_len))) 193 194 #define FILL_WR_RX_Q_ID(cid, qid, wr_iv) \ 195 htonl( \ 196 FW_CRYPTO_LOOKASIDE_WR_RX_CHID_V((cid)) | \ 197 FW_CRYPTO_LOOKASIDE_WR_RX_Q_ID_V((qid)) | \ 198 FW_CRYPTO_LOOKASIDE_WR_LCB_V(0) | \ 199 FW_CRYPTO_LOOKASIDE_WR_IV_V((wr_iv))) 200 201 #define FILL_ULPTX_CMD_DEST(cid) \ 202 htonl(ULPTX_CMD_V(ULP_TX_PKT) | \ 203 ULP_TXPKT_DEST_V(0) | \ 204 ULP_TXPKT_DATAMODIFY_V(0) | \ 205 ULP_TXPKT_CHANNELID_V((cid)) | \ 206 ULP_TXPKT_RO_V(1) | \ 207 ULP_TXPKT_FID_V(0)) 208 209 #define KEYCTX_ALIGN_PAD(bs) ({unsigned int _bs = (bs);\ 210 _bs == SHA1_DIGEST_SIZE ? 12 : 0; }) 211 212 #define FILL_PLD_SIZE_HASH_SIZE(payload_sgl_len, sgl_lengths, total_frags) \ 213 htonl(FW_CRYPTO_LOOKASIDE_WR_PLD_SIZE_V(payload_sgl_len ? \ 214 sgl_lengths[total_frags] : 0) |\ 215 FW_CRYPTO_LOOKASIDE_WR_HASH_SIZE_V(0)) 216 217 #define FILL_LEN_PKD(calc_tx_flits_ofld, skb) \ 218 htonl(FW_CRYPTO_LOOKASIDE_WR_LEN16_V(DIV_ROUND_UP((\ 219 calc_tx_flits_ofld(skb) * 8), 16))) 220 221 #define FILL_CMD_MORE(immdatalen) htonl(ULPTX_CMD_V(ULP_TX_SC_IMM) |\ 222 ULP_TX_SC_MORE_V((immdatalen) ? 0 : 1)) 223 224 #define MAX_NK 8 225 #define CRYPTO_MAX_IMM_TX_PKT_LEN 256 226 227 struct algo_param { 228 unsigned int auth_mode; 229 unsigned int mk_size; 230 unsigned int result_size; 231 }; 232 233 struct hash_wr_param { 234 unsigned int opad_needed; 235 unsigned int more; 236 unsigned int last; 237 struct algo_param alg_prm; 238 unsigned int sg_len; 239 unsigned int bfr_len; 240 u64 scmd1; 241 }; 242 243 enum { 244 AES_KEYLENGTH_128BIT = 128, 245 AES_KEYLENGTH_192BIT = 192, 246 AES_KEYLENGTH_256BIT = 256 247 }; 248 249 enum { 250 KEYLENGTH_3BYTES = 3, 251 KEYLENGTH_4BYTES = 4, 252 KEYLENGTH_6BYTES = 6, 253 KEYLENGTH_8BYTES = 8 254 }; 255 256 enum { 257 NUMBER_OF_ROUNDS_10 = 10, 258 NUMBER_OF_ROUNDS_12 = 12, 259 NUMBER_OF_ROUNDS_14 = 14, 260 }; 261 262 /* 263 * CCM defines values of 4, 6, 8, 10, 12, 14, and 16 octets, 264 * where they indicate the size of the integrity check value (ICV) 265 */ 266 enum { 267 AES_CCM_ICV_4 = 4, 268 AES_CCM_ICV_6 = 6, 269 AES_CCM_ICV_8 = 8, 270 AES_CCM_ICV_10 = 10, 271 AES_CCM_ICV_12 = 12, 272 AES_CCM_ICV_14 = 14, 273 AES_CCM_ICV_16 = 16 274 }; 275 276 struct hash_op_params { 277 unsigned char mk_size; 278 unsigned char pad_align; 279 unsigned char auth_mode; 280 char hash_name[MAX_HASH_NAME]; 281 unsigned short block_size; 282 unsigned short word_size; 283 unsigned short ipad_size; 284 }; 285 286 struct phys_sge_pairs { 287 __be16 len[8]; 288 __be64 addr[8]; 289 }; 290 291 struct phys_sge_parm { 292 unsigned int nents; 293 unsigned int obsize; 294 unsigned short qid; 295 unsigned char align; 296 }; 297 298 struct crypto_result { 299 struct completion completion; 300 int err; 301 }; 302 303 static const u32 sha1_init[SHA1_DIGEST_SIZE / 4] = { 304 SHA1_H0, SHA1_H1, SHA1_H2, SHA1_H3, SHA1_H4, 305 }; 306 307 static const u32 sha224_init[SHA256_DIGEST_SIZE / 4] = { 308 SHA224_H0, SHA224_H1, SHA224_H2, SHA224_H3, 309 SHA224_H4, SHA224_H5, SHA224_H6, SHA224_H7, 310 }; 311 312 static const u32 sha256_init[SHA256_DIGEST_SIZE / 4] = { 313 SHA256_H0, SHA256_H1, SHA256_H2, SHA256_H3, 314 SHA256_H4, SHA256_H5, SHA256_H6, SHA256_H7, 315 }; 316 317 static const u64 sha384_init[SHA512_DIGEST_SIZE / 8] = { 318 SHA384_H0, SHA384_H1, SHA384_H2, SHA384_H3, 319 SHA384_H4, SHA384_H5, SHA384_H6, SHA384_H7, 320 }; 321 322 static const u64 sha512_init[SHA512_DIGEST_SIZE / 8] = { 323 SHA512_H0, SHA512_H1, SHA512_H2, SHA512_H3, 324 SHA512_H4, SHA512_H5, SHA512_H6, SHA512_H7, 325 }; 326 327 static inline void copy_hash_init_values(char *key, int digestsize) 328 { 329 u8 i; 330 __be32 *dkey = (__be32 *)key; 331 u64 *ldkey = (u64 *)key; 332 __be64 *sha384 = (__be64 *)sha384_init; 333 __be64 *sha512 = (__be64 *)sha512_init; 334 335 switch (digestsize) { 336 case SHA1_DIGEST_SIZE: 337 for (i = 0; i < SHA1_INIT_STATE; i++) 338 dkey[i] = cpu_to_be32(sha1_init[i]); 339 break; 340 case SHA224_DIGEST_SIZE: 341 for (i = 0; i < SHA224_INIT_STATE; i++) 342 dkey[i] = cpu_to_be32(sha224_init[i]); 343 break; 344 case SHA256_DIGEST_SIZE: 345 for (i = 0; i < SHA256_INIT_STATE; i++) 346 dkey[i] = cpu_to_be32(sha256_init[i]); 347 break; 348 case SHA384_DIGEST_SIZE: 349 for (i = 0; i < SHA384_INIT_STATE; i++) 350 ldkey[i] = be64_to_cpu(sha384[i]); 351 break; 352 case SHA512_DIGEST_SIZE: 353 for (i = 0; i < SHA512_INIT_STATE; i++) 354 ldkey[i] = be64_to_cpu(sha512[i]); 355 break; 356 } 357 } 358 359 static const u8 sgl_lengths[20] = { 360 0, 1, 2, 3, 4, 4, 5, 6, 7, 7, 8, 9, 10, 10, 11, 12, 13, 13, 14, 15 361 }; 362 363 /* Number of len fields(8) * size of one addr field */ 364 #define PHYSDSGL_MAX_LEN_SIZE 16 365 366 static inline u16 get_space_for_phys_dsgl(unsigned int sgl_entr) 367 { 368 /* len field size + addr field size */ 369 return ((sgl_entr >> 3) + ((sgl_entr % 8) ? 370 1 : 0)) * PHYSDSGL_MAX_LEN_SIZE + 371 (sgl_entr << 3) + ((sgl_entr % 2 ? 1 : 0) << 3); 372 } 373 374 /* The AES s-transform matrix (s-box). */ 375 static const u8 aes_sbox[256] = { 376 99, 124, 119, 123, 242, 107, 111, 197, 48, 1, 103, 43, 254, 215, 377 171, 118, 202, 130, 201, 125, 250, 89, 71, 240, 173, 212, 162, 175, 378 156, 164, 114, 192, 183, 253, 147, 38, 54, 63, 247, 204, 52, 165, 379 229, 241, 113, 216, 49, 21, 4, 199, 35, 195, 24, 150, 5, 154, 7, 380 18, 128, 226, 235, 39, 178, 117, 9, 131, 44, 26, 27, 110, 90, 381 160, 82, 59, 214, 179, 41, 227, 47, 132, 83, 209, 0, 237, 32, 382 252, 177, 91, 106, 203, 190, 57, 74, 76, 88, 207, 208, 239, 170, 383 251, 67, 77, 51, 133, 69, 249, 2, 127, 80, 60, 159, 168, 81, 384 163, 64, 143, 146, 157, 56, 245, 188, 182, 218, 33, 16, 255, 243, 385 210, 205, 12, 19, 236, 95, 151, 68, 23, 196, 167, 126, 61, 100, 386 93, 25, 115, 96, 129, 79, 220, 34, 42, 144, 136, 70, 238, 184, 387 20, 222, 94, 11, 219, 224, 50, 58, 10, 73, 6, 36, 92, 194, 388 211, 172, 98, 145, 149, 228, 121, 231, 200, 55, 109, 141, 213, 78, 389 169, 108, 86, 244, 234, 101, 122, 174, 8, 186, 120, 37, 46, 28, 166, 390 180, 198, 232, 221, 116, 31, 75, 189, 139, 138, 112, 62, 181, 102, 391 72, 3, 246, 14, 97, 53, 87, 185, 134, 193, 29, 158, 225, 248, 392 152, 17, 105, 217, 142, 148, 155, 30, 135, 233, 206, 85, 40, 223, 393 140, 161, 137, 13, 191, 230, 66, 104, 65, 153, 45, 15, 176, 84, 394 187, 22 395 }; 396 397 static u32 aes_ks_subword(const u32 w) 398 { 399 u8 bytes[4]; 400 401 *(u32 *)(&bytes[0]) = w; 402 bytes[0] = aes_sbox[bytes[0]]; 403 bytes[1] = aes_sbox[bytes[1]]; 404 bytes[2] = aes_sbox[bytes[2]]; 405 bytes[3] = aes_sbox[bytes[3]]; 406 return *(u32 *)(&bytes[0]); 407 } 408 409 static u32 round_constant[11] = { 410 0x01000000, 0x02000000, 0x04000000, 0x08000000, 411 0x10000000, 0x20000000, 0x40000000, 0x80000000, 412 0x1B000000, 0x36000000, 0x6C000000 413 }; 414 415 /* dec_key - OUTPUT - Reverse round key 416 * key - INPUT - key 417 * keylength - INPUT - length of the key in number of bits 418 */ 419 static inline void get_aes_decrypt_key(unsigned char *dec_key, 420 const unsigned char *key, 421 unsigned int keylength) 422 { 423 u32 temp; 424 u32 w_ring[MAX_NK]; 425 int i, j, k; 426 u8 nr, nk; 427 428 switch (keylength) { 429 case AES_KEYLENGTH_128BIT: 430 nk = KEYLENGTH_4BYTES; 431 nr = NUMBER_OF_ROUNDS_10; 432 break; 433 434 case AES_KEYLENGTH_192BIT: 435 nk = KEYLENGTH_6BYTES; 436 nr = NUMBER_OF_ROUNDS_12; 437 break; 438 case AES_KEYLENGTH_256BIT: 439 nk = KEYLENGTH_8BYTES; 440 nr = NUMBER_OF_ROUNDS_14; 441 break; 442 default: 443 return; 444 } 445 for (i = 0; i < nk; i++ ) 446 w_ring[i] = be32_to_cpu(*(u32 *)&key[4 * i]); 447 448 i = 0; 449 temp = w_ring[nk - 1]; 450 while(i + nk < (nr + 1) * 4) { 451 if(!(i % nk)) { 452 /* RotWord(temp) */ 453 temp = (temp << 8) | (temp >> 24); 454 temp = aes_ks_subword(temp); 455 temp ^= round_constant[i / nk]; 456 } 457 else if (nk == 8 && (i % 4 == 0)) 458 temp = aes_ks_subword(temp); 459 w_ring[i % nk] ^= temp; 460 temp = w_ring[i % nk]; 461 i++; 462 } 463 i--; 464 for (k = 0, j = i % nk; k < nk; k++) { 465 *((u32 *)dec_key + k) = htonl(w_ring[j]); 466 j--; 467 if(j < 0) 468 j += nk; 469 } 470 } 471 472 #endif /* __CHCR_ALGO_H__ */ 473