drivers/crypto/chelsio/chcr_algo.h

   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 TLS_KEYCTX_RXFLIT_CNT_S 24
  90 #define TLS_KEYCTX_RXFLIT_CNT_V(x) ((x) << TLS_KEYCTX_RXFLIT_CNT_S)
  91
  92 #define TLS_KEYCTX_RXPROT_VER_S 20
  93 #define TLS_KEYCTX_RXPROT_VER_M 0xf
  94 #define TLS_KEYCTX_RXPROT_VER_V(x) ((x) << TLS_KEYCTX_RXPROT_VER_S)
  95
  96 #define TLS_KEYCTX_RXCIPH_MODE_S 16
  97 #define TLS_KEYCTX_RXCIPH_MODE_M 0xf
  98 #define TLS_KEYCTX_RXCIPH_MODE_V(x) ((x) << TLS_KEYCTX_RXCIPH_MODE_S)
  99
 100 #define TLS_KEYCTX_RXAUTH_MODE_S 12
 101 #define TLS_KEYCTX_RXAUTH_MODE_M 0xf
 102 #define TLS_KEYCTX_RXAUTH_MODE_V(x) ((x) << TLS_KEYCTX_RXAUTH_MODE_S)
 103
 104 #define TLS_KEYCTX_RXCIAU_CTRL_S 11
 105 #define TLS_KEYCTX_RXCIAU_CTRL_V(x) ((x) << TLS_KEYCTX_RXCIAU_CTRL_S)
 106
 107 #define TLS_KEYCTX_RX_SEQCTR_S 9
 108 #define TLS_KEYCTX_RX_SEQCTR_M 0x3
 109 #define TLS_KEYCTX_RX_SEQCTR_V(x) ((x) << TLS_KEYCTX_RX_SEQCTR_S)
 110
 111 #define TLS_KEYCTX_RX_VALID_S 8
 112 #define TLS_KEYCTX_RX_VALID_V(x) ((x) << TLS_KEYCTX_RX_VALID_S)
 113
 114 #define TLS_KEYCTX_RXCK_SIZE_S 3
 115 #define TLS_KEYCTX_RXCK_SIZE_M 0x7
 116 #define TLS_KEYCTX_RXCK_SIZE_V(x) ((x) << TLS_KEYCTX_RXCK_SIZE_S)
 117
 118 #define TLS_KEYCTX_RXMK_SIZE_S 0
 119 #define TLS_KEYCTX_RXMK_SIZE_M 0x7
 120 #define TLS_KEYCTX_RXMK_SIZE_V(x) ((x) << TLS_KEYCTX_RXMK_SIZE_S)
 121
 122 #define CHCR_HASH_MAX_DIGEST_SIZE 64
 123 #define CHCR_MAX_SHA_DIGEST_SIZE 64
 124
 125 #define IPSEC_TRUNCATED_ICV_SIZE 12
 126 #define TLS_TRUNCATED_HMAC_SIZE 10
 127 #define CBCMAC_DIGEST_SIZE 16
 128 #define MAX_HASH_NAME 20
 129
 130 #define SHA1_INIT_STATE_5X4B    5
 131 #define SHA256_INIT_STATE_8X4B  8
 132 #define SHA512_INIT_STATE_8X8B  8
 133 #define SHA1_INIT_STATE         SHA1_INIT_STATE_5X4B
 134 #define SHA224_INIT_STATE       SHA256_INIT_STATE_8X4B
 135 #define SHA256_INIT_STATE       SHA256_INIT_STATE_8X4B
 136 #define SHA384_INIT_STATE       SHA512_INIT_STATE_8X8B
 137 #define SHA512_INIT_STATE       SHA512_INIT_STATE_8X8B
 138
 139 #define DUMMY_BYTES 16
 140
 141 #define IPAD_DATA 0x36363636
 142 #define OPAD_DATA 0x5c5c5c5c
 143
 144 #define TRANSHDR_SIZE(kctx_len)\
 145         (sizeof(struct chcr_wr) +\
 146          kctx_len)
 147 #define CIPHER_TRANSHDR_SIZE(kctx_len, sge_pairs) \
 148         (TRANSHDR_SIZE((kctx_len)) + (sge_pairs) +\
 149          sizeof(struct cpl_rx_phys_dsgl) + AES_BLOCK_SIZE)
 150 #define HASH_TRANSHDR_SIZE(kctx_len)\
 151         (TRANSHDR_SIZE(kctx_len) + DUMMY_BYTES)
 152
 153
 154 #define FILL_SEC_CPL_OP_IVINSR(id, len, ofst)      \
 155         htonl( \
 156                CPL_TX_SEC_PDU_OPCODE_V(CPL_TX_SEC_PDU) | \
 157                CPL_TX_SEC_PDU_RXCHID_V((id)) | \
 158                CPL_TX_SEC_PDU_ACKFOLLOWS_V(0) | \
 159                CPL_TX_SEC_PDU_ULPTXLPBK_V(1) | \
 160                CPL_TX_SEC_PDU_CPLLEN_V((len)) | \
 161                CPL_TX_SEC_PDU_PLACEHOLDER_V(0) | \
 162                CPL_TX_SEC_PDU_IVINSRTOFST_V((ofst)))
 163
 164 #define  FILL_SEC_CPL_CIPHERSTOP_HI(a_start, a_stop, c_start, c_stop_hi) \
 165         htonl( \
 166                CPL_TX_SEC_PDU_AADSTART_V((a_start)) | \
 167                CPL_TX_SEC_PDU_AADSTOP_V((a_stop)) | \
 168                CPL_TX_SEC_PDU_CIPHERSTART_V((c_start)) | \
 169                CPL_TX_SEC_PDU_CIPHERSTOP_HI_V((c_stop_hi)))
 170
 171 #define  FILL_SEC_CPL_AUTHINSERT(c_stop_lo, a_start, a_stop, a_inst) \
 172         htonl( \
 173                CPL_TX_SEC_PDU_CIPHERSTOP_LO_V((c_stop_lo)) | \
 174                 CPL_TX_SEC_PDU_AUTHSTART_V((a_start)) | \
 175                 CPL_TX_SEC_PDU_AUTHSTOP_V((a_stop)) | \
 176                 CPL_TX_SEC_PDU_AUTHINSERT_V((a_inst)))
 177
 178 #define  FILL_SEC_CPL_SCMD0_SEQNO(ctrl, seq, cmode, amode, opad, size)  \
 179                 htonl( \
 180                 SCMD_SEQ_NO_CTRL_V(0) | \
 181                 SCMD_STATUS_PRESENT_V(0) | \
 182                 SCMD_PROTO_VERSION_V(CHCR_SCMD_PROTO_VERSION_GENERIC) | \
 183                 SCMD_ENC_DEC_CTRL_V((ctrl)) | \
 184                 SCMD_CIPH_AUTH_SEQ_CTRL_V((seq)) | \
 185                 SCMD_CIPH_MODE_V((cmode)) | \
 186                 SCMD_AUTH_MODE_V((amode)) | \
 187                 SCMD_HMAC_CTRL_V((opad)) | \
 188                 SCMD_IV_SIZE_V((size)) | \
 189                 SCMD_NUM_IVS_V(0))
 190
 191 #define FILL_SEC_CPL_IVGEN_HDRLEN(last, more, ctx_in, mac, ivdrop, len) htonl( \
 192                 SCMD_ENB_DBGID_V(0) | \
 193                 SCMD_IV_GEN_CTRL_V(0) | \
 194                 SCMD_LAST_FRAG_V((last)) | \
 195                 SCMD_MORE_FRAGS_V((more)) | \
 196                 SCMD_TLS_COMPPDU_V(0) | \
 197                 SCMD_KEY_CTX_INLINE_V((ctx_in)) | \
 198                 SCMD_TLS_FRAG_ENABLE_V(0) | \
 199                 SCMD_MAC_ONLY_V((mac)) |  \
 200                 SCMD_AADIVDROP_V((ivdrop)) | \
 201                 SCMD_HDR_LEN_V((len)))
 202
 203 #define  FILL_KEY_CTX_HDR(ck_size, mk_size, d_ck, opad, ctx_len) \
 204                 htonl(KEY_CONTEXT_VALID_V(1) | \
 205                       KEY_CONTEXT_CK_SIZE_V((ck_size)) | \
 206                       KEY_CONTEXT_MK_SIZE_V(mk_size) | \
 207                       KEY_CONTEXT_DUAL_CK_V((d_ck)) | \
 208                       KEY_CONTEXT_OPAD_PRESENT_V((opad)) | \
 209                       KEY_CONTEXT_SALT_PRESENT_V(1) | \
 210                       KEY_CONTEXT_CTX_LEN_V((ctx_len)))
 211
 212 #define  FILL_KEY_CRX_HDR(ck_size, mk_size, d_ck, opad, ctx_len) \
 213                 htonl(TLS_KEYCTX_RXMK_SIZE_V(mk_size) | \
 214                       TLS_KEYCTX_RXCK_SIZE_V(ck_size) | \
 215                       TLS_KEYCTX_RX_VALID_V(1) | \
 216                       TLS_KEYCTX_RX_SEQCTR_V(3) | \
 217                       TLS_KEYCTX_RXAUTH_MODE_V(4) | \
 218                       TLS_KEYCTX_RXCIPH_MODE_V(2) | \
 219                       TLS_KEYCTX_RXFLIT_CNT_V((ctx_len)))
 220
 221 #define FILL_WR_OP_CCTX_SIZE \
 222                 htonl( \
 223                         FW_CRYPTO_LOOKASIDE_WR_OPCODE_V( \
 224                         FW_CRYPTO_LOOKASIDE_WR) | \
 225                         FW_CRYPTO_LOOKASIDE_WR_COMPL_V(0) | \
 226                         FW_CRYPTO_LOOKASIDE_WR_IMM_LEN_V((0)) | \
 227                         FW_CRYPTO_LOOKASIDE_WR_CCTX_LOC_V(0) | \
 228                         FW_CRYPTO_LOOKASIDE_WR_CCTX_SIZE_V(0))
 229
 230 #define FILL_WR_RX_Q_ID(cid, qid, lcb, fid) \
 231                 htonl( \
 232                         FW_CRYPTO_LOOKASIDE_WR_RX_CHID_V((cid)) | \
 233                         FW_CRYPTO_LOOKASIDE_WR_RX_Q_ID_V((qid)) | \
 234                         FW_CRYPTO_LOOKASIDE_WR_LCB_V((lcb)) | \
 235                         FW_CRYPTO_LOOKASIDE_WR_IV_V((IV_NOP)) | \
 236                         FW_CRYPTO_LOOKASIDE_WR_FQIDX_V(fid))
 237
 238 #define FILL_ULPTX_CMD_DEST(cid, qid) \
 239         htonl(ULPTX_CMD_V(ULP_TX_PKT) | \
 240               ULP_TXPKT_DEST_V(0) | \
 241               ULP_TXPKT_DATAMODIFY_V(0) | \
 242               ULP_TXPKT_CHANNELID_V((cid)) | \
 243               ULP_TXPKT_RO_V(1) | \
 244               ULP_TXPKT_FID_V(qid))
 245
 246 #define KEYCTX_ALIGN_PAD(bs) ({unsigned int _bs = (bs);\
 247                               _bs == SHA1_DIGEST_SIZE ? 12 : 0; })
 248
 249 #define FILL_PLD_SIZE_HASH_SIZE(payload_sgl_len, sgl_lengths, total_frags) \
 250         htonl(FW_CRYPTO_LOOKASIDE_WR_PLD_SIZE_V(payload_sgl_len ? \
 251                                                 sgl_lengths[total_frags] : 0) |\
 252               FW_CRYPTO_LOOKASIDE_WR_HASH_SIZE_V(0))
 253
 254 #define FILL_LEN_PKD(calc_tx_flits_ofld, skb) \
 255         htonl(FW_CRYPTO_LOOKASIDE_WR_LEN16_V(DIV_ROUND_UP((\
 256                                            calc_tx_flits_ofld(skb) * 8), 16)))
 257
 258 #define FILL_CMD_MORE(immdatalen) htonl(ULPTX_CMD_V(ULP_TX_SC_IMM) |\
 259                                         ULP_TX_SC_MORE_V((immdatalen)))
 260 #define MAX_NK 8
 261 #define MAX_DSGL_ENT                    32
 262 #define MIN_AUTH_SG                     1 /* IV */
 263 #define MIN_GCM_SG                      1 /* IV */
 264 #define MIN_DIGEST_SG                   1 /*Partial Buffer*/
 265 #define MIN_CCM_SG                      1 /*IV+B0*/
 266 #define CIP_SPACE_LEFT(len) \
 267         ((SGE_MAX_WR_LEN - CIP_WR_MIN_LEN - (len)))
 268 #define HASH_SPACE_LEFT(len) \
 269         ((SGE_MAX_WR_LEN - HASH_WR_MIN_LEN - (len)))
 270
 271 struct algo_param {
 272         unsigned int auth_mode;
 273         unsigned int mk_size;
 274         unsigned int result_size;
 275 };
 276
 277 struct hash_wr_param {
 278         struct algo_param alg_prm;
 279         unsigned int opad_needed;
 280         unsigned int more;
 281         unsigned int last;
 282         unsigned int kctx_len;
 283         unsigned int sg_len;
 284         unsigned int bfr_len;
 285         unsigned int hash_size;
 286         u64 scmd1;
 287 };
 288
 289 struct cipher_wr_param {
 290         struct skcipher_request *req;
 291         char *iv;
 292         int bytes;
 293         unsigned short qid;
 294 };
 295 enum {
 296         AES_KEYLENGTH_128BIT = 128,
 297         AES_KEYLENGTH_192BIT = 192,
 298         AES_KEYLENGTH_256BIT = 256
 299 };
 300
 301 enum {
 302         KEYLENGTH_3BYTES = 3,
 303         KEYLENGTH_4BYTES = 4,
 304         KEYLENGTH_6BYTES = 6,
 305         KEYLENGTH_8BYTES = 8
 306 };
 307
 308 enum {
 309         NUMBER_OF_ROUNDS_10 = 10,
 310         NUMBER_OF_ROUNDS_12 = 12,
 311         NUMBER_OF_ROUNDS_14 = 14,
 312 };
 313
 314 /*
 315  * CCM defines values of 4, 6, 8, 10, 12, 14, and 16 octets,
 316  * where they indicate the size of the integrity check value (ICV)
 317  */
 318 enum {
 319         ICV_4  = 4,
 320         ICV_6  = 6,
 321         ICV_8  = 8,
 322         ICV_10 = 10,
 323         ICV_12 = 12,
 324         ICV_13 = 13,
 325         ICV_14 = 14,
 326         ICV_15 = 15,
 327         ICV_16 = 16
 328 };
 329
 330 struct phys_sge_pairs {
 331         __be16 len[8];
 332         __be64 addr[8];
 333 };
 334
 335
 336 static const u32 chcr_sha1_init[SHA1_DIGEST_SIZE / 4] = {
 337                 SHA1_H0, SHA1_H1, SHA1_H2, SHA1_H3, SHA1_H4,
 338 };
 339
 340 static const u32 chcr_sha224_init[SHA256_DIGEST_SIZE / 4] = {
 341                 SHA224_H0, SHA224_H1, SHA224_H2, SHA224_H3,
 342                 SHA224_H4, SHA224_H5, SHA224_H6, SHA224_H7,
 343 };
 344
 345 static const u32 chcr_sha256_init[SHA256_DIGEST_SIZE / 4] = {
 346                 SHA256_H0, SHA256_H1, SHA256_H2, SHA256_H3,
 347                 SHA256_H4, SHA256_H5, SHA256_H6, SHA256_H7,
 348 };
 349
 350 static const u64 chcr_sha384_init[SHA512_DIGEST_SIZE / 8] = {
 351                 SHA384_H0, SHA384_H1, SHA384_H2, SHA384_H3,
 352                 SHA384_H4, SHA384_H5, SHA384_H6, SHA384_H7,
 353 };
 354
 355 static const u64 chcr_sha512_init[SHA512_DIGEST_SIZE / 8] = {
 356                 SHA512_H0, SHA512_H1, SHA512_H2, SHA512_H3,
 357                 SHA512_H4, SHA512_H5, SHA512_H6, SHA512_H7,
 358 };
 359
 360 static inline void copy_hash_init_values(char *key, int digestsize)
 361 {
 362         u8 i;
 363         __be32 *dkey = (__be32 *)key;
 364         u64 *ldkey = (u64 *)key;
 365         __be64 *sha384 = (__be64 *)chcr_sha384_init;
 366         __be64 *sha512 = (__be64 *)chcr_sha512_init;
 367
 368         switch (digestsize) {
 369         case SHA1_DIGEST_SIZE:
 370                 for (i = 0; i < SHA1_INIT_STATE; i++)
 371                         dkey[i] = cpu_to_be32(chcr_sha1_init[i]);
 372                 break;
 373         case SHA224_DIGEST_SIZE:
 374                 for (i = 0; i < SHA224_INIT_STATE; i++)
 375                         dkey[i] = cpu_to_be32(chcr_sha224_init[i]);
 376                 break;
 377         case SHA256_DIGEST_SIZE:
 378                 for (i = 0; i < SHA256_INIT_STATE; i++)
 379                         dkey[i] = cpu_to_be32(chcr_sha256_init[i]);
 380                 break;
 381         case SHA384_DIGEST_SIZE:
 382                 for (i = 0; i < SHA384_INIT_STATE; i++)
 383                         ldkey[i] = be64_to_cpu(sha384[i]);
 384                 break;
 385         case SHA512_DIGEST_SIZE:
 386                 for (i = 0; i < SHA512_INIT_STATE; i++)
 387                         ldkey[i] = be64_to_cpu(sha512[i]);
 388                 break;
 389         }
 390 }
 391
 392 static const u8 sgl_lengths[20] = {
 393         0, 1, 2, 3, 4, 4, 5, 6, 7, 7, 8, 9, 10, 10, 11, 12, 13, 13, 14, 15
 394 };
 395
 396 /* Number of len fields(8) * size of one addr field */
 397 #define PHYSDSGL_MAX_LEN_SIZE 16
 398
 399 static inline u16 get_space_for_phys_dsgl(unsigned int sgl_entr)
 400 {
 401         /* len field size + addr field size */
 402         return ((sgl_entr >> 3) + ((sgl_entr % 8) ?
 403                                    1 : 0)) * PHYSDSGL_MAX_LEN_SIZE +
 404                 (sgl_entr << 3) + ((sgl_entr % 2 ? 1 : 0) << 3);
 405 }
 406
 407 /* The AES s-transform matrix (s-box). */
 408 static const u8 aes_sbox[256] = {
 409         99,  124, 119, 123, 242, 107, 111, 197, 48,  1,   103, 43,  254, 215,
 410         171, 118, 202, 130, 201, 125, 250, 89,  71,  240, 173, 212, 162, 175,
 411         156, 164, 114, 192, 183, 253, 147, 38,  54,  63,  247, 204, 52,  165,
 412         229, 241, 113, 216, 49,  21, 4,   199, 35,  195, 24,  150, 5, 154, 7,
 413         18,  128, 226, 235, 39,  178, 117, 9,   131, 44,  26,  27,  110, 90,
 414         160, 82,  59,  214, 179, 41,  227, 47,  132, 83,  209, 0,   237, 32,
 415         252, 177, 91,  106, 203, 190, 57,  74,  76,  88,  207, 208, 239, 170,
 416         251, 67,  77,  51,  133, 69,  249, 2,   127, 80,  60,  159, 168, 81,
 417         163, 64,  143, 146, 157, 56,  245, 188, 182, 218, 33,  16,  255, 243,
 418         210, 205, 12,  19,  236, 95,  151, 68,  23,  196, 167, 126, 61,  100,
 419         93,  25,  115, 96,  129, 79,  220, 34,  42,  144, 136, 70,  238, 184,
 420         20,  222, 94,  11,  219, 224, 50,  58,  10,  73,  6,   36,  92,  194,
 421         211, 172, 98,  145, 149, 228, 121, 231, 200, 55,  109, 141, 213, 78,
 422         169, 108, 86,  244, 234, 101, 122, 174, 8, 186, 120, 37,  46,  28, 166,
 423         180, 198, 232, 221, 116, 31,  75,  189, 139, 138, 112, 62,  181, 102,
 424         72,  3,   246, 14,  97,  53,  87,  185, 134, 193, 29,  158, 225, 248,
 425         152, 17,  105, 217, 142, 148, 155, 30,  135, 233, 206, 85,  40,  223,
 426         140, 161, 137, 13,  191, 230, 66,  104, 65,  153, 45,  15,  176, 84,
 427         187, 22
 428 };
 429
 430 static inline u32 aes_ks_subword(const u32 w)
 431 {
 432         u8 bytes[4];
 433
 434         *(u32 *)(&bytes[0]) = w;
 435         bytes[0] = aes_sbox[bytes[0]];
 436         bytes[1] = aes_sbox[bytes[1]];
 437         bytes[2] = aes_sbox[bytes[2]];
 438         bytes[3] = aes_sbox[bytes[3]];
 439         return *(u32 *)(&bytes[0]);
 440 }
 441
 442 #endif /* __CHCR_ALGO_H__ */