Commit | Line | Data |
---|---|---|
324429d7 HS |
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 = 0; | |
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 | for (k = 0, j = i % nk; k < nk; k++) { | |
464 | *((u32 *)dec_key + k) = htonl(w_ring[j]); | |
465 | j--; | |
466 | if(j < 0) | |
467 | j += nk; | |
468 | } | |
469 | } | |
470 | ||
471 | #endif /* __CHCR_ALGO_H__ */ |