Commit | Line | Data |
---|---|---|
9d12ba86 RR |
1 | /* |
2 | * Copyright 2016 Broadcom | |
3 | * | |
4 | * This program is free software; you can redistribute it and/or modify | |
5 | * it under the terms of the GNU General Public License, version 2, as | |
6 | * published by the Free Software Foundation (the "GPL"). | |
7 | * | |
8 | * This program is distributed in the hope that it will be useful, but | |
9 | * WITHOUT ANY WARRANTY; without even the implied warranty of | |
10 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | |
11 | * General Public License version 2 (GPLv2) for more details. | |
12 | * | |
13 | * You should have received a copy of the GNU General Public License | |
14 | * version 2 (GPLv2) along with this source code. | |
15 | */ | |
16 | ||
17 | /* | |
18 | * This file works with the SPU2 version of the SPU. SPU2 has different message | |
19 | * formats than the previous version of the SPU. All SPU message format | |
20 | * differences should be hidden in the spux.c,h files. | |
21 | */ | |
22 | ||
23 | #include <linux/kernel.h> | |
24 | #include <linux/string.h> | |
25 | ||
26 | #include "util.h" | |
27 | #include "spu.h" | |
28 | #include "spu2.h" | |
29 | ||
30 | #define SPU2_TX_STATUS_LEN 0 /* SPU2 has no STATUS in input packet */ | |
31 | ||
32 | /* | |
33 | * Controlled by pkt_stat_cnt field in CRYPTO_SS_SPU0_CORE_SPU2_CONTROL0 | |
34 | * register. Defaults to 2. | |
35 | */ | |
36 | #define SPU2_RX_STATUS_LEN 2 | |
37 | ||
38 | enum spu2_proto_sel { | |
39 | SPU2_PROTO_RESV = 0, | |
40 | SPU2_MACSEC_SECTAG8_ECB = 1, | |
41 | SPU2_MACSEC_SECTAG8_SCB = 2, | |
42 | SPU2_MACSEC_SECTAG16 = 3, | |
43 | SPU2_MACSEC_SECTAG16_8_XPN = 4, | |
44 | SPU2_IPSEC = 5, | |
45 | SPU2_IPSEC_ESN = 6, | |
46 | SPU2_TLS_CIPHER = 7, | |
47 | SPU2_TLS_AEAD = 8, | |
48 | SPU2_DTLS_CIPHER = 9, | |
49 | SPU2_DTLS_AEAD = 10 | |
50 | }; | |
51 | ||
52 | char *spu2_cipher_type_names[] = { "None", "AES128", "AES192", "AES256", | |
53 | "DES", "3DES" | |
54 | }; | |
55 | ||
56 | char *spu2_cipher_mode_names[] = { "ECB", "CBC", "CTR", "CFB", "OFB", "XTS", | |
57 | "CCM", "GCM" | |
58 | }; | |
59 | ||
60 | char *spu2_hash_type_names[] = { "None", "AES128", "AES192", "AES256", | |
61 | "Reserved", "Reserved", "MD5", "SHA1", "SHA224", "SHA256", "SHA384", | |
62 | "SHA512", "SHA512/224", "SHA512/256", "SHA3-224", "SHA3-256", | |
63 | "SHA3-384", "SHA3-512" | |
64 | }; | |
65 | ||
66 | char *spu2_hash_mode_names[] = { "CMAC", "CBC-MAC", "XCBC-MAC", "HMAC", | |
67 | "Rabin", "CCM", "GCM", "Reserved" | |
68 | }; | |
69 | ||
70 | static char *spu2_ciph_type_name(enum spu2_cipher_type cipher_type) | |
71 | { | |
72 | if (cipher_type >= SPU2_CIPHER_TYPE_LAST) | |
73 | return "Reserved"; | |
74 | return spu2_cipher_type_names[cipher_type]; | |
75 | } | |
76 | ||
77 | static char *spu2_ciph_mode_name(enum spu2_cipher_mode cipher_mode) | |
78 | { | |
79 | if (cipher_mode >= SPU2_CIPHER_MODE_LAST) | |
80 | return "Reserved"; | |
81 | return spu2_cipher_mode_names[cipher_mode]; | |
82 | } | |
83 | ||
84 | static char *spu2_hash_type_name(enum spu2_hash_type hash_type) | |
85 | { | |
86 | if (hash_type >= SPU2_HASH_TYPE_LAST) | |
87 | return "Reserved"; | |
88 | return spu2_hash_type_names[hash_type]; | |
89 | } | |
90 | ||
91 | static char *spu2_hash_mode_name(enum spu2_hash_mode hash_mode) | |
92 | { | |
93 | if (hash_mode >= SPU2_HASH_MODE_LAST) | |
94 | return "Reserved"; | |
95 | return spu2_hash_mode_names[hash_mode]; | |
96 | } | |
97 | ||
98 | /* | |
99 | * Convert from a software cipher mode value to the corresponding value | |
100 | * for SPU2. | |
101 | */ | |
102 | static int spu2_cipher_mode_xlate(enum spu_cipher_mode cipher_mode, | |
103 | enum spu2_cipher_mode *spu2_mode) | |
104 | { | |
105 | switch (cipher_mode) { | |
106 | case CIPHER_MODE_ECB: | |
107 | *spu2_mode = SPU2_CIPHER_MODE_ECB; | |
108 | break; | |
109 | case CIPHER_MODE_CBC: | |
110 | *spu2_mode = SPU2_CIPHER_MODE_CBC; | |
111 | break; | |
112 | case CIPHER_MODE_OFB: | |
113 | *spu2_mode = SPU2_CIPHER_MODE_OFB; | |
114 | break; | |
115 | case CIPHER_MODE_CFB: | |
116 | *spu2_mode = SPU2_CIPHER_MODE_CFB; | |
117 | break; | |
118 | case CIPHER_MODE_CTR: | |
119 | *spu2_mode = SPU2_CIPHER_MODE_CTR; | |
120 | break; | |
121 | case CIPHER_MODE_CCM: | |
122 | *spu2_mode = SPU2_CIPHER_MODE_CCM; | |
123 | break; | |
124 | case CIPHER_MODE_GCM: | |
125 | *spu2_mode = SPU2_CIPHER_MODE_GCM; | |
126 | break; | |
127 | case CIPHER_MODE_XTS: | |
128 | *spu2_mode = SPU2_CIPHER_MODE_XTS; | |
129 | break; | |
130 | default: | |
131 | return -EINVAL; | |
132 | } | |
133 | return 0; | |
134 | } | |
135 | ||
136 | /** | |
137 | * spu2_cipher_xlate() - Convert a cipher {alg/mode/type} triple to a SPU2 | |
138 | * cipher type and mode. | |
139 | * @cipher_alg: [in] cipher algorithm value from software enumeration | |
140 | * @cipher_mode: [in] cipher mode value from software enumeration | |
141 | * @cipher_type: [in] cipher type value from software enumeration | |
142 | * @spu2_type: [out] cipher type value used by spu2 hardware | |
143 | * @spu2_mode: [out] cipher mode value used by spu2 hardware | |
144 | * | |
145 | * Return: 0 if successful | |
146 | */ | |
147 | static int spu2_cipher_xlate(enum spu_cipher_alg cipher_alg, | |
148 | enum spu_cipher_mode cipher_mode, | |
149 | enum spu_cipher_type cipher_type, | |
150 | enum spu2_cipher_type *spu2_type, | |
151 | enum spu2_cipher_mode *spu2_mode) | |
152 | { | |
153 | int err; | |
154 | ||
155 | err = spu2_cipher_mode_xlate(cipher_mode, spu2_mode); | |
156 | if (err) { | |
157 | flow_log("Invalid cipher mode %d\n", cipher_mode); | |
158 | return err; | |
159 | } | |
160 | ||
161 | switch (cipher_alg) { | |
162 | case CIPHER_ALG_NONE: | |
163 | *spu2_type = SPU2_CIPHER_TYPE_NONE; | |
164 | break; | |
165 | case CIPHER_ALG_RC4: | |
166 | /* SPU2 does not support RC4 */ | |
167 | err = -EINVAL; | |
168 | *spu2_type = SPU2_CIPHER_TYPE_NONE; | |
169 | break; | |
170 | case CIPHER_ALG_DES: | |
171 | *spu2_type = SPU2_CIPHER_TYPE_DES; | |
172 | break; | |
173 | case CIPHER_ALG_3DES: | |
174 | *spu2_type = SPU2_CIPHER_TYPE_3DES; | |
175 | break; | |
176 | case CIPHER_ALG_AES: | |
177 | switch (cipher_type) { | |
178 | case CIPHER_TYPE_AES128: | |
179 | *spu2_type = SPU2_CIPHER_TYPE_AES128; | |
180 | break; | |
181 | case CIPHER_TYPE_AES192: | |
182 | *spu2_type = SPU2_CIPHER_TYPE_AES192; | |
183 | break; | |
184 | case CIPHER_TYPE_AES256: | |
185 | *spu2_type = SPU2_CIPHER_TYPE_AES256; | |
186 | break; | |
187 | default: | |
188 | err = -EINVAL; | |
189 | } | |
190 | break; | |
191 | case CIPHER_ALG_LAST: | |
192 | default: | |
193 | err = -EINVAL; | |
194 | break; | |
195 | } | |
196 | ||
197 | if (err) | |
198 | flow_log("Invalid cipher alg %d or type %d\n", | |
199 | cipher_alg, cipher_type); | |
200 | return err; | |
201 | } | |
202 | ||
203 | /* | |
204 | * Convert from a software hash mode value to the corresponding value | |
205 | * for SPU2. Note that HASH_MODE_NONE and HASH_MODE_XCBC have the same value. | |
206 | */ | |
207 | static int spu2_hash_mode_xlate(enum hash_mode hash_mode, | |
208 | enum spu2_hash_mode *spu2_mode) | |
209 | { | |
210 | switch (hash_mode) { | |
211 | case HASH_MODE_XCBC: | |
212 | *spu2_mode = SPU2_HASH_MODE_XCBC_MAC; | |
213 | break; | |
214 | case HASH_MODE_CMAC: | |
215 | *spu2_mode = SPU2_HASH_MODE_CMAC; | |
216 | break; | |
217 | case HASH_MODE_HMAC: | |
218 | *spu2_mode = SPU2_HASH_MODE_HMAC; | |
219 | break; | |
220 | case HASH_MODE_CCM: | |
221 | *spu2_mode = SPU2_HASH_MODE_CCM; | |
222 | break; | |
223 | case HASH_MODE_GCM: | |
224 | *spu2_mode = SPU2_HASH_MODE_GCM; | |
225 | break; | |
226 | default: | |
227 | return -EINVAL; | |
228 | } | |
229 | return 0; | |
230 | } | |
231 | ||
232 | /** | |
233 | * spu2_hash_xlate() - Convert a hash {alg/mode/type} triple to a SPU2 hash type | |
234 | * and mode. | |
235 | * @hash_alg: [in] hash algorithm value from software enumeration | |
236 | * @hash_mode: [in] hash mode value from software enumeration | |
237 | * @hash_type: [in] hash type value from software enumeration | |
238 | * @ciph_type: [in] cipher type value from software enumeration | |
239 | * @spu2_type: [out] hash type value used by SPU2 hardware | |
240 | * @spu2_mode: [out] hash mode value used by SPU2 hardware | |
241 | * | |
242 | * Return: 0 if successful | |
243 | */ | |
244 | static int | |
245 | spu2_hash_xlate(enum hash_alg hash_alg, enum hash_mode hash_mode, | |
246 | enum hash_type hash_type, enum spu_cipher_type ciph_type, | |
247 | enum spu2_hash_type *spu2_type, enum spu2_hash_mode *spu2_mode) | |
248 | { | |
249 | int err; | |
250 | ||
251 | err = spu2_hash_mode_xlate(hash_mode, spu2_mode); | |
252 | if (err) { | |
253 | flow_log("Invalid hash mode %d\n", hash_mode); | |
254 | return err; | |
255 | } | |
256 | ||
257 | switch (hash_alg) { | |
258 | case HASH_ALG_NONE: | |
259 | *spu2_type = SPU2_HASH_TYPE_NONE; | |
260 | break; | |
261 | case HASH_ALG_MD5: | |
262 | *spu2_type = SPU2_HASH_TYPE_MD5; | |
263 | break; | |
264 | case HASH_ALG_SHA1: | |
265 | *spu2_type = SPU2_HASH_TYPE_SHA1; | |
266 | break; | |
267 | case HASH_ALG_SHA224: | |
268 | *spu2_type = SPU2_HASH_TYPE_SHA224; | |
269 | break; | |
270 | case HASH_ALG_SHA256: | |
271 | *spu2_type = SPU2_HASH_TYPE_SHA256; | |
272 | break; | |
273 | case HASH_ALG_SHA384: | |
274 | *spu2_type = SPU2_HASH_TYPE_SHA384; | |
275 | break; | |
276 | case HASH_ALG_SHA512: | |
277 | *spu2_type = SPU2_HASH_TYPE_SHA512; | |
278 | break; | |
279 | case HASH_ALG_AES: | |
280 | switch (ciph_type) { | |
281 | case CIPHER_TYPE_AES128: | |
282 | *spu2_type = SPU2_HASH_TYPE_AES128; | |
283 | break; | |
284 | case CIPHER_TYPE_AES192: | |
285 | *spu2_type = SPU2_HASH_TYPE_AES192; | |
286 | break; | |
287 | case CIPHER_TYPE_AES256: | |
288 | *spu2_type = SPU2_HASH_TYPE_AES256; | |
289 | break; | |
290 | default: | |
291 | err = -EINVAL; | |
292 | } | |
293 | break; | |
294 | case HASH_ALG_SHA3_224: | |
295 | *spu2_type = SPU2_HASH_TYPE_SHA3_224; | |
296 | break; | |
297 | case HASH_ALG_SHA3_256: | |
298 | *spu2_type = SPU2_HASH_TYPE_SHA3_256; | |
299 | break; | |
300 | case HASH_ALG_SHA3_384: | |
301 | *spu2_type = SPU2_HASH_TYPE_SHA3_384; | |
302 | break; | |
303 | case HASH_ALG_SHA3_512: | |
304 | *spu2_type = SPU2_HASH_TYPE_SHA3_512; | |
a7e6e5d8 | 305 | break; |
9d12ba86 RR |
306 | case HASH_ALG_LAST: |
307 | default: | |
308 | err = -EINVAL; | |
309 | break; | |
310 | } | |
311 | ||
312 | if (err) | |
313 | flow_log("Invalid hash alg %d or type %d\n", | |
314 | hash_alg, hash_type); | |
315 | return err; | |
316 | } | |
317 | ||
318 | /* Dump FMD ctrl0. The ctrl0 input is in host byte order */ | |
319 | static void spu2_dump_fmd_ctrl0(u64 ctrl0) | |
320 | { | |
321 | enum spu2_cipher_type ciph_type; | |
322 | enum spu2_cipher_mode ciph_mode; | |
323 | enum spu2_hash_type hash_type; | |
324 | enum spu2_hash_mode hash_mode; | |
325 | char *ciph_name; | |
326 | char *ciph_mode_name; | |
327 | char *hash_name; | |
328 | char *hash_mode_name; | |
329 | u8 cfb; | |
330 | u8 proto; | |
331 | ||
332 | packet_log(" FMD CTRL0 %#16llx\n", ctrl0); | |
333 | if (ctrl0 & SPU2_CIPH_ENCRYPT_EN) | |
334 | packet_log(" encrypt\n"); | |
335 | else | |
336 | packet_log(" decrypt\n"); | |
337 | ||
338 | ciph_type = (ctrl0 & SPU2_CIPH_TYPE) >> SPU2_CIPH_TYPE_SHIFT; | |
339 | ciph_name = spu2_ciph_type_name(ciph_type); | |
340 | packet_log(" Cipher type: %s\n", ciph_name); | |
341 | ||
342 | if (ciph_type != SPU2_CIPHER_TYPE_NONE) { | |
343 | ciph_mode = (ctrl0 & SPU2_CIPH_MODE) >> SPU2_CIPH_MODE_SHIFT; | |
344 | ciph_mode_name = spu2_ciph_mode_name(ciph_mode); | |
345 | packet_log(" Cipher mode: %s\n", ciph_mode_name); | |
346 | } | |
347 | ||
348 | cfb = (ctrl0 & SPU2_CFB_MASK) >> SPU2_CFB_MASK_SHIFT; | |
349 | packet_log(" CFB %#x\n", cfb); | |
350 | ||
351 | proto = (ctrl0 & SPU2_PROTO_SEL) >> SPU2_PROTO_SEL_SHIFT; | |
352 | packet_log(" protocol %#x\n", proto); | |
353 | ||
354 | if (ctrl0 & SPU2_HASH_FIRST) | |
355 | packet_log(" hash first\n"); | |
356 | else | |
357 | packet_log(" cipher first\n"); | |
358 | ||
359 | if (ctrl0 & SPU2_CHK_TAG) | |
360 | packet_log(" check tag\n"); | |
361 | ||
362 | hash_type = (ctrl0 & SPU2_HASH_TYPE) >> SPU2_HASH_TYPE_SHIFT; | |
363 | hash_name = spu2_hash_type_name(hash_type); | |
364 | packet_log(" Hash type: %s\n", hash_name); | |
365 | ||
366 | if (hash_type != SPU2_HASH_TYPE_NONE) { | |
367 | hash_mode = (ctrl0 & SPU2_HASH_MODE) >> SPU2_HASH_MODE_SHIFT; | |
368 | hash_mode_name = spu2_hash_mode_name(hash_mode); | |
369 | packet_log(" Hash mode: %s\n", hash_mode_name); | |
370 | } | |
371 | ||
372 | if (ctrl0 & SPU2_CIPH_PAD_EN) { | |
373 | packet_log(" Cipher pad: %#2llx\n", | |
374 | (ctrl0 & SPU2_CIPH_PAD) >> SPU2_CIPH_PAD_SHIFT); | |
375 | } | |
376 | } | |
377 | ||
378 | /* Dump FMD ctrl1. The ctrl1 input is in host byte order */ | |
379 | static void spu2_dump_fmd_ctrl1(u64 ctrl1) | |
380 | { | |
381 | u8 hash_key_len; | |
382 | u8 ciph_key_len; | |
383 | u8 ret_iv_len; | |
384 | u8 iv_offset; | |
385 | u8 iv_len; | |
386 | u8 hash_tag_len; | |
387 | u8 ret_md; | |
388 | ||
389 | packet_log(" FMD CTRL1 %#16llx\n", ctrl1); | |
390 | if (ctrl1 & SPU2_TAG_LOC) | |
391 | packet_log(" Tag after payload\n"); | |
392 | ||
393 | packet_log(" Msg includes "); | |
394 | if (ctrl1 & SPU2_HAS_FR_DATA) | |
395 | packet_log("FD "); | |
396 | if (ctrl1 & SPU2_HAS_AAD1) | |
397 | packet_log("AAD1 "); | |
398 | if (ctrl1 & SPU2_HAS_NAAD) | |
399 | packet_log("NAAD "); | |
400 | if (ctrl1 & SPU2_HAS_AAD2) | |
401 | packet_log("AAD2 "); | |
402 | if (ctrl1 & SPU2_HAS_ESN) | |
403 | packet_log("ESN "); | |
404 | packet_log("\n"); | |
405 | ||
406 | hash_key_len = (ctrl1 & SPU2_HASH_KEY_LEN) >> SPU2_HASH_KEY_LEN_SHIFT; | |
407 | packet_log(" Hash key len %u\n", hash_key_len); | |
408 | ||
409 | ciph_key_len = (ctrl1 & SPU2_CIPH_KEY_LEN) >> SPU2_CIPH_KEY_LEN_SHIFT; | |
410 | packet_log(" Cipher key len %u\n", ciph_key_len); | |
411 | ||
412 | if (ctrl1 & SPU2_GENIV) | |
413 | packet_log(" Generate IV\n"); | |
414 | ||
415 | if (ctrl1 & SPU2_HASH_IV) | |
416 | packet_log(" IV included in hash\n"); | |
417 | ||
418 | if (ctrl1 & SPU2_RET_IV) | |
419 | packet_log(" Return IV in output before payload\n"); | |
420 | ||
421 | ret_iv_len = (ctrl1 & SPU2_RET_IV_LEN) >> SPU2_RET_IV_LEN_SHIFT; | |
422 | packet_log(" Length of returned IV %u bytes\n", | |
423 | ret_iv_len ? ret_iv_len : 16); | |
424 | ||
425 | iv_offset = (ctrl1 & SPU2_IV_OFFSET) >> SPU2_IV_OFFSET_SHIFT; | |
426 | packet_log(" IV offset %u\n", iv_offset); | |
427 | ||
428 | iv_len = (ctrl1 & SPU2_IV_LEN) >> SPU2_IV_LEN_SHIFT; | |
429 | packet_log(" Input IV len %u bytes\n", iv_len); | |
430 | ||
431 | hash_tag_len = (ctrl1 & SPU2_HASH_TAG_LEN) >> SPU2_HASH_TAG_LEN_SHIFT; | |
432 | packet_log(" Hash tag length %u bytes\n", hash_tag_len); | |
433 | ||
434 | packet_log(" Return "); | |
435 | ret_md = (ctrl1 & SPU2_RETURN_MD) >> SPU2_RETURN_MD_SHIFT; | |
436 | if (ret_md) | |
437 | packet_log("FMD "); | |
438 | if (ret_md == SPU2_RET_FMD_OMD) | |
439 | packet_log("OMD "); | |
440 | else if (ret_md == SPU2_RET_FMD_OMD_IV) | |
441 | packet_log("OMD IV "); | |
442 | if (ctrl1 & SPU2_RETURN_FD) | |
443 | packet_log("FD "); | |
444 | if (ctrl1 & SPU2_RETURN_AAD1) | |
445 | packet_log("AAD1 "); | |
446 | if (ctrl1 & SPU2_RETURN_NAAD) | |
447 | packet_log("NAAD "); | |
448 | if (ctrl1 & SPU2_RETURN_AAD2) | |
449 | packet_log("AAD2 "); | |
450 | if (ctrl1 & SPU2_RETURN_PAY) | |
451 | packet_log("Payload"); | |
452 | packet_log("\n"); | |
453 | } | |
454 | ||
455 | /* Dump FMD ctrl2. The ctrl2 input is in host byte order */ | |
456 | static void spu2_dump_fmd_ctrl2(u64 ctrl2) | |
457 | { | |
458 | packet_log(" FMD CTRL2 %#16llx\n", ctrl2); | |
459 | ||
460 | packet_log(" AAD1 offset %llu length %llu bytes\n", | |
461 | ctrl2 & SPU2_AAD1_OFFSET, | |
462 | (ctrl2 & SPU2_AAD1_LEN) >> SPU2_AAD1_LEN_SHIFT); | |
463 | packet_log(" AAD2 offset %llu\n", | |
464 | (ctrl2 & SPU2_AAD2_OFFSET) >> SPU2_AAD2_OFFSET_SHIFT); | |
465 | packet_log(" Payload offset %llu\n", | |
466 | (ctrl2 & SPU2_PL_OFFSET) >> SPU2_PL_OFFSET_SHIFT); | |
467 | } | |
468 | ||
469 | /* Dump FMD ctrl3. The ctrl3 input is in host byte order */ | |
470 | static void spu2_dump_fmd_ctrl3(u64 ctrl3) | |
471 | { | |
472 | packet_log(" FMD CTRL3 %#16llx\n", ctrl3); | |
473 | ||
474 | packet_log(" Payload length %llu bytes\n", ctrl3 & SPU2_PL_LEN); | |
475 | packet_log(" TLS length %llu bytes\n", | |
476 | (ctrl3 & SPU2_TLS_LEN) >> SPU2_TLS_LEN_SHIFT); | |
477 | } | |
478 | ||
479 | static void spu2_dump_fmd(struct SPU2_FMD *fmd) | |
480 | { | |
481 | spu2_dump_fmd_ctrl0(le64_to_cpu(fmd->ctrl0)); | |
482 | spu2_dump_fmd_ctrl1(le64_to_cpu(fmd->ctrl1)); | |
483 | spu2_dump_fmd_ctrl2(le64_to_cpu(fmd->ctrl2)); | |
484 | spu2_dump_fmd_ctrl3(le64_to_cpu(fmd->ctrl3)); | |
485 | } | |
486 | ||
487 | static void spu2_dump_omd(u8 *omd, u16 hash_key_len, u16 ciph_key_len, | |
488 | u16 hash_iv_len, u16 ciph_iv_len) | |
489 | { | |
490 | u8 *ptr = omd; | |
491 | ||
492 | packet_log(" OMD:\n"); | |
493 | ||
494 | if (hash_key_len) { | |
495 | packet_log(" Hash Key Length %u bytes\n", hash_key_len); | |
496 | packet_dump(" KEY: ", ptr, hash_key_len); | |
497 | ptr += hash_key_len; | |
498 | } | |
499 | ||
500 | if (ciph_key_len) { | |
501 | packet_log(" Cipher Key Length %u bytes\n", ciph_key_len); | |
502 | packet_dump(" KEY: ", ptr, ciph_key_len); | |
503 | ptr += ciph_key_len; | |
504 | } | |
505 | ||
506 | if (hash_iv_len) { | |
507 | packet_log(" Hash IV Length %u bytes\n", hash_iv_len); | |
508 | packet_dump(" hash IV: ", ptr, hash_iv_len); | |
509 | ptr += ciph_key_len; | |
510 | } | |
511 | ||
512 | if (ciph_iv_len) { | |
513 | packet_log(" Cipher IV Length %u bytes\n", ciph_iv_len); | |
514 | packet_dump(" cipher IV: ", ptr, ciph_iv_len); | |
515 | } | |
516 | } | |
517 | ||
518 | /* Dump a SPU2 header for debug */ | |
519 | void spu2_dump_msg_hdr(u8 *buf, unsigned int buf_len) | |
520 | { | |
521 | struct SPU2_FMD *fmd = (struct SPU2_FMD *)buf; | |
522 | u8 *omd; | |
523 | u64 ctrl1; | |
524 | u16 hash_key_len; | |
525 | u16 ciph_key_len; | |
526 | u16 hash_iv_len; | |
527 | u16 ciph_iv_len; | |
528 | u16 omd_len; | |
529 | ||
530 | packet_log("\n"); | |
531 | packet_log("SPU2 message header %p len: %u\n", buf, buf_len); | |
532 | ||
533 | spu2_dump_fmd(fmd); | |
534 | omd = (u8 *)(fmd + 1); | |
535 | ||
536 | ctrl1 = le64_to_cpu(fmd->ctrl1); | |
537 | hash_key_len = (ctrl1 & SPU2_HASH_KEY_LEN) >> SPU2_HASH_KEY_LEN_SHIFT; | |
538 | ciph_key_len = (ctrl1 & SPU2_CIPH_KEY_LEN) >> SPU2_CIPH_KEY_LEN_SHIFT; | |
539 | hash_iv_len = 0; | |
540 | ciph_iv_len = (ctrl1 & SPU2_IV_LEN) >> SPU2_IV_LEN_SHIFT; | |
541 | spu2_dump_omd(omd, hash_key_len, ciph_key_len, hash_iv_len, | |
542 | ciph_iv_len); | |
543 | ||
544 | /* Double check sanity */ | |
545 | omd_len = hash_key_len + ciph_key_len + hash_iv_len + ciph_iv_len; | |
546 | if (FMD_SIZE + omd_len != buf_len) { | |
547 | packet_log | |
548 | (" Packet parsed incorrectly. buf_len %u, sum of MD %zu\n", | |
549 | buf_len, FMD_SIZE + omd_len); | |
550 | } | |
551 | packet_log("\n"); | |
552 | } | |
553 | ||
554 | /** | |
555 | * spu2_fmd_init() - At setkey time, initialize the fixed meta data for | |
556 | * subsequent ablkcipher requests for this context. | |
557 | * @spu2_cipher_type: Cipher algorithm | |
558 | * @spu2_mode: Cipher mode | |
559 | * @cipher_key_len: Length of cipher key, in bytes | |
560 | * @cipher_iv_len: Length of cipher initialization vector, in bytes | |
561 | * | |
562 | * Return: 0 (success) | |
563 | */ | |
564 | static int spu2_fmd_init(struct SPU2_FMD *fmd, | |
565 | enum spu2_cipher_type spu2_type, | |
566 | enum spu2_cipher_mode spu2_mode, | |
567 | u32 cipher_key_len, u32 cipher_iv_len) | |
568 | { | |
569 | u64 ctrl0; | |
570 | u64 ctrl1; | |
571 | u64 ctrl2; | |
572 | u64 ctrl3; | |
573 | u32 aad1_offset; | |
574 | u32 aad2_offset; | |
575 | u16 aad1_len = 0; | |
576 | u64 payload_offset; | |
577 | ||
578 | ctrl0 = (spu2_type << SPU2_CIPH_TYPE_SHIFT) | | |
579 | (spu2_mode << SPU2_CIPH_MODE_SHIFT); | |
580 | ||
581 | ctrl1 = (cipher_key_len << SPU2_CIPH_KEY_LEN_SHIFT) | | |
582 | ((u64)cipher_iv_len << SPU2_IV_LEN_SHIFT) | | |
583 | ((u64)SPU2_RET_FMD_ONLY << SPU2_RETURN_MD_SHIFT) | SPU2_RETURN_PAY; | |
584 | ||
585 | /* | |
586 | * AAD1 offset is from start of FD. FD length is always 0 for this | |
587 | * driver. So AAD1_offset is always 0. | |
588 | */ | |
589 | aad1_offset = 0; | |
590 | aad2_offset = aad1_offset; | |
591 | payload_offset = 0; | |
592 | ctrl2 = aad1_offset | | |
593 | (aad1_len << SPU2_AAD1_LEN_SHIFT) | | |
594 | (aad2_offset << SPU2_AAD2_OFFSET_SHIFT) | | |
595 | (payload_offset << SPU2_PL_OFFSET_SHIFT); | |
596 | ||
597 | ctrl3 = 0; | |
598 | ||
599 | fmd->ctrl0 = cpu_to_le64(ctrl0); | |
600 | fmd->ctrl1 = cpu_to_le64(ctrl1); | |
601 | fmd->ctrl2 = cpu_to_le64(ctrl2); | |
602 | fmd->ctrl3 = cpu_to_le64(ctrl3); | |
603 | ||
604 | return 0; | |
605 | } | |
606 | ||
607 | /** | |
608 | * spu2_fmd_ctrl0_write() - Write ctrl0 field in fixed metadata (FMD) field of | |
609 | * SPU request packet. | |
610 | * @fmd: Start of FMD field to be written | |
611 | * @is_inbound: true if decrypting. false if encrypting. | |
612 | * @authFirst: true if alg authenticates before encrypting | |
613 | * @protocol: protocol selector | |
614 | * @cipher_type: cipher algorithm | |
615 | * @cipher_mode: cipher mode | |
616 | * @auth_type: authentication type | |
617 | * @auth_mode: authentication mode | |
618 | */ | |
619 | static void spu2_fmd_ctrl0_write(struct SPU2_FMD *fmd, | |
620 | bool is_inbound, bool auth_first, | |
621 | enum spu2_proto_sel protocol, | |
622 | enum spu2_cipher_type cipher_type, | |
623 | enum spu2_cipher_mode cipher_mode, | |
624 | enum spu2_hash_type auth_type, | |
625 | enum spu2_hash_mode auth_mode) | |
626 | { | |
627 | u64 ctrl0 = 0; | |
628 | ||
629 | if ((cipher_type != SPU2_CIPHER_TYPE_NONE) && !is_inbound) | |
630 | ctrl0 |= SPU2_CIPH_ENCRYPT_EN; | |
631 | ||
632 | ctrl0 |= ((u64)cipher_type << SPU2_CIPH_TYPE_SHIFT) | | |
633 | ((u64)cipher_mode << SPU2_CIPH_MODE_SHIFT); | |
634 | ||
635 | if (protocol) | |
636 | ctrl0 |= (u64)protocol << SPU2_PROTO_SEL_SHIFT; | |
637 | ||
638 | if (auth_first) | |
639 | ctrl0 |= SPU2_HASH_FIRST; | |
640 | ||
641 | if (is_inbound && (auth_type != SPU2_HASH_TYPE_NONE)) | |
642 | ctrl0 |= SPU2_CHK_TAG; | |
643 | ||
644 | ctrl0 |= (((u64)auth_type << SPU2_HASH_TYPE_SHIFT) | | |
645 | ((u64)auth_mode << SPU2_HASH_MODE_SHIFT)); | |
646 | ||
647 | fmd->ctrl0 = cpu_to_le64(ctrl0); | |
648 | } | |
649 | ||
650 | /** | |
651 | * spu2_fmd_ctrl1_write() - Write ctrl1 field in fixed metadata (FMD) field of | |
652 | * SPU request packet. | |
653 | * @fmd: Start of FMD field to be written | |
654 | * @assoc_size: Length of additional associated data, in bytes | |
655 | * @auth_key_len: Length of authentication key, in bytes | |
656 | * @cipher_key_len: Length of cipher key, in bytes | |
657 | * @gen_iv: If true, hw generates IV and returns in response | |
658 | * @hash_iv: IV participates in hash. Used for IPSEC and TLS. | |
659 | * @return_iv: Return IV in output packet before payload | |
660 | * @ret_iv_len: Length of IV returned from SPU, in bytes | |
661 | * @ret_iv_offset: Offset into full IV of start of returned IV | |
662 | * @cipher_iv_len: Length of input cipher IV, in bytes | |
663 | * @digest_size: Length of digest (aka, hash tag or ICV), in bytes | |
664 | * @return_payload: Return payload in SPU response | |
665 | * @return_md : return metadata in SPU response | |
666 | * | |
667 | * Packet can have AAD2 w/o AAD1. For algorithms currently supported, | |
668 | * associated data goes in AAD2. | |
669 | */ | |
670 | static void spu2_fmd_ctrl1_write(struct SPU2_FMD *fmd, bool is_inbound, | |
671 | u64 assoc_size, | |
672 | u64 auth_key_len, u64 cipher_key_len, | |
673 | bool gen_iv, bool hash_iv, bool return_iv, | |
674 | u64 ret_iv_len, u64 ret_iv_offset, | |
675 | u64 cipher_iv_len, u64 digest_size, | |
676 | bool return_payload, bool return_md) | |
677 | { | |
678 | u64 ctrl1 = 0; | |
679 | ||
680 | if (is_inbound && digest_size) | |
681 | ctrl1 |= SPU2_TAG_LOC; | |
682 | ||
683 | if (assoc_size) { | |
684 | ctrl1 |= SPU2_HAS_AAD2; | |
685 | ctrl1 |= SPU2_RETURN_AAD2; /* need aad2 for gcm aes esp */ | |
686 | } | |
687 | ||
688 | if (auth_key_len) | |
689 | ctrl1 |= ((auth_key_len << SPU2_HASH_KEY_LEN_SHIFT) & | |
690 | SPU2_HASH_KEY_LEN); | |
691 | ||
692 | if (cipher_key_len) | |
693 | ctrl1 |= ((cipher_key_len << SPU2_CIPH_KEY_LEN_SHIFT) & | |
694 | SPU2_CIPH_KEY_LEN); | |
695 | ||
696 | if (gen_iv) | |
697 | ctrl1 |= SPU2_GENIV; | |
698 | ||
699 | if (hash_iv) | |
700 | ctrl1 |= SPU2_HASH_IV; | |
701 | ||
702 | if (return_iv) { | |
703 | ctrl1 |= SPU2_RET_IV; | |
704 | ctrl1 |= ret_iv_len << SPU2_RET_IV_LEN_SHIFT; | |
705 | ctrl1 |= ret_iv_offset << SPU2_IV_OFFSET_SHIFT; | |
706 | } | |
707 | ||
708 | ctrl1 |= ((cipher_iv_len << SPU2_IV_LEN_SHIFT) & SPU2_IV_LEN); | |
709 | ||
710 | if (digest_size) | |
711 | ctrl1 |= ((digest_size << SPU2_HASH_TAG_LEN_SHIFT) & | |
712 | SPU2_HASH_TAG_LEN); | |
713 | ||
714 | /* Let's ask for the output pkt to include FMD, but don't need to | |
715 | * get keys and IVs back in OMD. | |
716 | */ | |
717 | if (return_md) | |
718 | ctrl1 |= ((u64)SPU2_RET_FMD_ONLY << SPU2_RETURN_MD_SHIFT); | |
719 | else | |
720 | ctrl1 |= ((u64)SPU2_RET_NO_MD << SPU2_RETURN_MD_SHIFT); | |
721 | ||
722 | /* Crypto API does not get assoc data back. So no need for AAD2. */ | |
723 | ||
724 | if (return_payload) | |
725 | ctrl1 |= SPU2_RETURN_PAY; | |
726 | ||
727 | fmd->ctrl1 = cpu_to_le64(ctrl1); | |
728 | } | |
729 | ||
730 | /** | |
731 | * spu2_fmd_ctrl2_write() - Set the ctrl2 field in the fixed metadata field of | |
732 | * SPU2 header. | |
733 | * @fmd: Start of FMD field to be written | |
734 | * @cipher_offset: Number of bytes from Start of Packet (end of FD field) where | |
735 | * data to be encrypted or decrypted begins | |
736 | * @auth_key_len: Length of authentication key, in bytes | |
737 | * @auth_iv_len: Length of authentication initialization vector, in bytes | |
738 | * @cipher_key_len: Length of cipher key, in bytes | |
739 | * @cipher_iv_len: Length of cipher IV, in bytes | |
740 | */ | |
741 | static void spu2_fmd_ctrl2_write(struct SPU2_FMD *fmd, u64 cipher_offset, | |
742 | u64 auth_key_len, u64 auth_iv_len, | |
743 | u64 cipher_key_len, u64 cipher_iv_len) | |
744 | { | |
745 | u64 ctrl2; | |
746 | u64 aad1_offset; | |
747 | u64 aad2_offset; | |
748 | u16 aad1_len = 0; | |
749 | u64 payload_offset; | |
750 | ||
751 | /* AAD1 offset is from start of FD. FD length always 0. */ | |
752 | aad1_offset = 0; | |
753 | ||
754 | aad2_offset = aad1_offset; | |
755 | payload_offset = cipher_offset; | |
756 | ctrl2 = aad1_offset | | |
757 | (aad1_len << SPU2_AAD1_LEN_SHIFT) | | |
758 | (aad2_offset << SPU2_AAD2_OFFSET_SHIFT) | | |
759 | (payload_offset << SPU2_PL_OFFSET_SHIFT); | |
760 | ||
761 | fmd->ctrl2 = cpu_to_le64(ctrl2); | |
762 | } | |
763 | ||
764 | /** | |
765 | * spu2_fmd_ctrl3_write() - Set the ctrl3 field in FMD | |
766 | * @fmd: Fixed meta data. First field in SPU2 msg header. | |
767 | * @payload_len: Length of payload, in bytes | |
768 | */ | |
769 | static void spu2_fmd_ctrl3_write(struct SPU2_FMD *fmd, u64 payload_len) | |
770 | { | |
771 | u64 ctrl3; | |
772 | ||
773 | ctrl3 = payload_len & SPU2_PL_LEN; | |
774 | ||
775 | fmd->ctrl3 = cpu_to_le64(ctrl3); | |
776 | } | |
777 | ||
778 | /** | |
779 | * spu2_ctx_max_payload() - Determine the maximum length of the payload for a | |
780 | * SPU message for a given cipher and hash alg context. | |
781 | * @cipher_alg: The cipher algorithm | |
782 | * @cipher_mode: The cipher mode | |
783 | * @blocksize: The size of a block of data for this algo | |
784 | * | |
785 | * For SPU2, the hardware generally ignores the PayloadLen field in ctrl3 of | |
786 | * FMD and just keeps computing until it receives a DMA descriptor with the EOF | |
787 | * flag set. So we consider the max payload to be infinite. AES CCM is an | |
788 | * exception. | |
789 | * | |
790 | * Return: Max payload length in bytes | |
791 | */ | |
792 | u32 spu2_ctx_max_payload(enum spu_cipher_alg cipher_alg, | |
793 | enum spu_cipher_mode cipher_mode, | |
794 | unsigned int blocksize) | |
795 | { | |
796 | if ((cipher_alg == CIPHER_ALG_AES) && | |
797 | (cipher_mode == CIPHER_MODE_CCM)) { | |
798 | u32 excess = SPU2_MAX_PAYLOAD % blocksize; | |
799 | ||
800 | return SPU2_MAX_PAYLOAD - excess; | |
801 | } else { | |
802 | return SPU_MAX_PAYLOAD_INF; | |
803 | } | |
804 | } | |
805 | ||
806 | /** | |
807 | * spu_payload_length() - Given a SPU2 message header, extract the payload | |
808 | * length. | |
809 | * @spu_hdr: Start of SPU message header (FMD) | |
810 | * | |
811 | * Return: payload length, in bytes | |
812 | */ | |
813 | u32 spu2_payload_length(u8 *spu_hdr) | |
814 | { | |
815 | struct SPU2_FMD *fmd = (struct SPU2_FMD *)spu_hdr; | |
816 | u32 pl_len; | |
817 | u64 ctrl3; | |
818 | ||
819 | ctrl3 = le64_to_cpu(fmd->ctrl3); | |
820 | pl_len = ctrl3 & SPU2_PL_LEN; | |
821 | ||
822 | return pl_len; | |
823 | } | |
824 | ||
825 | /** | |
826 | * spu_response_hdr_len() - Determine the expected length of a SPU response | |
827 | * header. | |
828 | * @auth_key_len: Length of authentication key, in bytes | |
829 | * @enc_key_len: Length of encryption key, in bytes | |
830 | * | |
831 | * For SPU2, includes just FMD. OMD is never requested. | |
832 | * | |
833 | * Return: Length of FMD, in bytes | |
834 | */ | |
835 | u16 spu2_response_hdr_len(u16 auth_key_len, u16 enc_key_len, bool is_hash) | |
836 | { | |
837 | return FMD_SIZE; | |
838 | } | |
839 | ||
840 | /** | |
841 | * spu_hash_pad_len() - Calculate the length of hash padding required to extend | |
842 | * data to a full block size. | |
843 | * @hash_alg: hash algorithm | |
844 | * @hash_mode: hash mode | |
845 | * @chunksize: length of data, in bytes | |
846 | * @hash_block_size: size of a hash block, in bytes | |
847 | * | |
848 | * SPU2 hardware does all hash padding | |
849 | * | |
850 | * Return: length of hash pad in bytes | |
851 | */ | |
852 | u16 spu2_hash_pad_len(enum hash_alg hash_alg, enum hash_mode hash_mode, | |
853 | u32 chunksize, u16 hash_block_size) | |
854 | { | |
855 | return 0; | |
856 | } | |
857 | ||
858 | /** | |
859 | * spu2_gcm_ccm_padlen() - Determine the length of GCM/CCM padding for either | |
860 | * the AAD field or the data. | |
861 | * | |
862 | * Return: 0. Unlike SPU-M, SPU2 hardware does any GCM/CCM padding required. | |
863 | */ | |
864 | u32 spu2_gcm_ccm_pad_len(enum spu_cipher_mode cipher_mode, | |
865 | unsigned int data_size) | |
866 | { | |
867 | return 0; | |
868 | } | |
869 | ||
870 | /** | |
871 | * spu_assoc_resp_len() - Determine the size of the AAD2 buffer needed to catch | |
872 | * associated data in a SPU2 output packet. | |
873 | * @cipher_mode: cipher mode | |
874 | * @assoc_len: length of additional associated data, in bytes | |
875 | * @iv_len: length of initialization vector, in bytes | |
876 | * @is_encrypt: true if encrypting. false if decrypt. | |
877 | * | |
878 | * Return: Length of buffer to catch associated data in response | |
879 | */ | |
880 | u32 spu2_assoc_resp_len(enum spu_cipher_mode cipher_mode, | |
881 | unsigned int assoc_len, unsigned int iv_len, | |
882 | bool is_encrypt) | |
883 | { | |
884 | u32 resp_len = assoc_len; | |
885 | ||
886 | if (is_encrypt) | |
887 | /* gcm aes esp has to write 8-byte IV in response */ | |
888 | resp_len += iv_len; | |
889 | return resp_len; | |
890 | } | |
891 | ||
892 | /* | |
893 | * spu_aead_ivlen() - Calculate the length of the AEAD IV to be included | |
894 | * in a SPU request after the AAD and before the payload. | |
895 | * @cipher_mode: cipher mode | |
896 | * @iv_ctr_len: initialization vector length in bytes | |
897 | * | |
898 | * For SPU2, AEAD IV is included in OMD and does not need to be repeated | |
899 | * prior to the payload. | |
900 | * | |
901 | * Return: Length of AEAD IV in bytes | |
902 | */ | |
903 | u8 spu2_aead_ivlen(enum spu_cipher_mode cipher_mode, u16 iv_len) | |
904 | { | |
905 | return 0; | |
906 | } | |
907 | ||
908 | /** | |
909 | * spu2_hash_type() - Determine the type of hash operation. | |
910 | * @src_sent: The number of bytes in the current request that have already | |
911 | * been sent to the SPU to be hashed. | |
912 | * | |
913 | * SPU2 always does a FULL hash operation | |
914 | */ | |
915 | enum hash_type spu2_hash_type(u32 src_sent) | |
916 | { | |
917 | return HASH_TYPE_FULL; | |
918 | } | |
919 | ||
920 | /** | |
921 | * spu2_digest_size() - Determine the size of a hash digest to expect the SPU to | |
922 | * return. | |
923 | * alg_digest_size: Number of bytes in the final digest for the given algo | |
924 | * alg: The hash algorithm | |
925 | * htype: Type of hash operation (init, update, full, etc) | |
926 | * | |
927 | */ | |
928 | u32 spu2_digest_size(u32 alg_digest_size, enum hash_alg alg, | |
929 | enum hash_type htype) | |
930 | { | |
931 | return alg_digest_size; | |
932 | } | |
933 | ||
934 | /** | |
935 | * spu_create_request() - Build a SPU2 request message header, includint FMD and | |
936 | * OMD. | |
937 | * @spu_hdr: Start of buffer where SPU request header is to be written | |
938 | * @req_opts: SPU request message options | |
939 | * @cipher_parms: Parameters related to cipher algorithm | |
940 | * @hash_parms: Parameters related to hash algorithm | |
941 | * @aead_parms: Parameters related to AEAD operation | |
942 | * @data_size: Length of data to be encrypted or authenticated. If AEAD, does | |
943 | * not include length of AAD. | |
944 | * | |
945 | * Construct the message starting at spu_hdr. Caller should allocate this buffer | |
946 | * in DMA-able memory at least SPU_HEADER_ALLOC_LEN bytes long. | |
947 | * | |
948 | * Return: the length of the SPU header in bytes. 0 if an error occurs. | |
949 | */ | |
950 | u32 spu2_create_request(u8 *spu_hdr, | |
951 | struct spu_request_opts *req_opts, | |
952 | struct spu_cipher_parms *cipher_parms, | |
953 | struct spu_hash_parms *hash_parms, | |
954 | struct spu_aead_parms *aead_parms, | |
955 | unsigned int data_size) | |
956 | { | |
957 | struct SPU2_FMD *fmd; | |
958 | u8 *ptr; | |
959 | unsigned int buf_len; | |
960 | int err; | |
961 | enum spu2_cipher_type spu2_ciph_type = SPU2_CIPHER_TYPE_NONE; | |
962 | enum spu2_cipher_mode spu2_ciph_mode; | |
963 | enum spu2_hash_type spu2_auth_type = SPU2_HASH_TYPE_NONE; | |
964 | enum spu2_hash_mode spu2_auth_mode; | |
965 | bool return_md = true; | |
966 | enum spu2_proto_sel proto = SPU2_PROTO_RESV; | |
967 | ||
968 | /* size of the payload */ | |
969 | unsigned int payload_len = | |
970 | hash_parms->prebuf_len + data_size + hash_parms->pad_len - | |
971 | ((req_opts->is_aead && req_opts->is_inbound) ? | |
972 | hash_parms->digestsize : 0); | |
973 | ||
974 | /* offset of prebuf or data from start of AAD2 */ | |
975 | unsigned int cipher_offset = aead_parms->assoc_size + | |
976 | aead_parms->aad_pad_len + aead_parms->iv_len; | |
977 | ||
978 | #ifdef DEBUG | |
979 | /* total size of the data following OMD (without STAT word padding) */ | |
980 | unsigned int real_db_size = spu_real_db_size(aead_parms->assoc_size, | |
981 | aead_parms->iv_len, | |
982 | hash_parms->prebuf_len, | |
983 | data_size, | |
984 | aead_parms->aad_pad_len, | |
985 | aead_parms->data_pad_len, | |
986 | hash_parms->pad_len); | |
987 | #endif | |
988 | unsigned int assoc_size = aead_parms->assoc_size; | |
989 | ||
990 | if (req_opts->is_aead && | |
991 | (cipher_parms->alg == CIPHER_ALG_AES) && | |
992 | (cipher_parms->mode == CIPHER_MODE_GCM)) | |
993 | /* | |
994 | * On SPU 2, aes gcm cipher first on encrypt, auth first on | |
995 | * decrypt | |
996 | */ | |
997 | req_opts->auth_first = req_opts->is_inbound; | |
998 | ||
999 | /* and do opposite for ccm (auth 1st on encrypt) */ | |
1000 | if (req_opts->is_aead && | |
1001 | (cipher_parms->alg == CIPHER_ALG_AES) && | |
1002 | (cipher_parms->mode == CIPHER_MODE_CCM)) | |
1003 | req_opts->auth_first = !req_opts->is_inbound; | |
1004 | ||
1005 | flow_log("%s()\n", __func__); | |
1006 | flow_log(" in:%u authFirst:%u\n", | |
1007 | req_opts->is_inbound, req_opts->auth_first); | |
1008 | flow_log(" cipher alg:%u mode:%u type %u\n", cipher_parms->alg, | |
1009 | cipher_parms->mode, cipher_parms->type); | |
1010 | flow_log(" is_esp: %s\n", req_opts->is_esp ? "yes" : "no"); | |
1011 | flow_log(" key: %d\n", cipher_parms->key_len); | |
1012 | flow_dump(" key: ", cipher_parms->key_buf, cipher_parms->key_len); | |
1013 | flow_log(" iv: %d\n", cipher_parms->iv_len); | |
1014 | flow_dump(" iv: ", cipher_parms->iv_buf, cipher_parms->iv_len); | |
1015 | flow_log(" auth alg:%u mode:%u type %u\n", | |
1016 | hash_parms->alg, hash_parms->mode, hash_parms->type); | |
1017 | flow_log(" digestsize: %u\n", hash_parms->digestsize); | |
1018 | flow_log(" authkey: %d\n", hash_parms->key_len); | |
1019 | flow_dump(" authkey: ", hash_parms->key_buf, hash_parms->key_len); | |
1020 | flow_log(" assoc_size:%u\n", assoc_size); | |
1021 | flow_log(" prebuf_len:%u\n", hash_parms->prebuf_len); | |
1022 | flow_log(" data_size:%u\n", data_size); | |
1023 | flow_log(" hash_pad_len:%u\n", hash_parms->pad_len); | |
1024 | flow_log(" real_db_size:%u\n", real_db_size); | |
1025 | flow_log(" cipher_offset:%u payload_len:%u\n", | |
1026 | cipher_offset, payload_len); | |
1027 | flow_log(" aead_iv: %u\n", aead_parms->iv_len); | |
1028 | ||
1029 | /* Convert to spu2 values for cipher alg, hash alg */ | |
1030 | err = spu2_cipher_xlate(cipher_parms->alg, cipher_parms->mode, | |
1031 | cipher_parms->type, | |
1032 | &spu2_ciph_type, &spu2_ciph_mode); | |
1033 | ||
1034 | /* If we are doing GCM hashing only - either via rfc4543 transform | |
1035 | * or because we happen to do GCM with AAD only and no payload - we | |
1036 | * need to configure hardware to use hash key rather than cipher key | |
1037 | * and put data into payload. This is because unlike SPU-M, running | |
1038 | * GCM cipher with 0 size payload is not permitted. | |
1039 | */ | |
1040 | if ((req_opts->is_rfc4543) || | |
1041 | ((spu2_ciph_mode == SPU2_CIPHER_MODE_GCM) && | |
1042 | (payload_len == 0))) { | |
1043 | /* Use hashing (only) and set up hash key */ | |
1044 | spu2_ciph_type = SPU2_CIPHER_TYPE_NONE; | |
1045 | hash_parms->key_len = cipher_parms->key_len; | |
1046 | memcpy(hash_parms->key_buf, cipher_parms->key_buf, | |
1047 | cipher_parms->key_len); | |
1048 | cipher_parms->key_len = 0; | |
1049 | ||
1050 | if (req_opts->is_rfc4543) | |
1051 | payload_len += assoc_size; | |
1052 | else | |
1053 | payload_len = assoc_size; | |
1054 | cipher_offset = 0; | |
1055 | assoc_size = 0; | |
1056 | } | |
1057 | ||
1058 | if (err) | |
1059 | return 0; | |
1060 | ||
1061 | flow_log("spu2 cipher type %s, cipher mode %s\n", | |
1062 | spu2_ciph_type_name(spu2_ciph_type), | |
1063 | spu2_ciph_mode_name(spu2_ciph_mode)); | |
1064 | ||
1065 | err = spu2_hash_xlate(hash_parms->alg, hash_parms->mode, | |
1066 | hash_parms->type, | |
1067 | cipher_parms->type, | |
1068 | &spu2_auth_type, &spu2_auth_mode); | |
1069 | if (err) | |
1070 | return 0; | |
1071 | ||
1072 | flow_log("spu2 hash type %s, hash mode %s\n", | |
1073 | spu2_hash_type_name(spu2_auth_type), | |
1074 | spu2_hash_mode_name(spu2_auth_mode)); | |
1075 | ||
1076 | fmd = (struct SPU2_FMD *)spu_hdr; | |
1077 | ||
1078 | spu2_fmd_ctrl0_write(fmd, req_opts->is_inbound, req_opts->auth_first, | |
1079 | proto, spu2_ciph_type, spu2_ciph_mode, | |
1080 | spu2_auth_type, spu2_auth_mode); | |
1081 | ||
1082 | spu2_fmd_ctrl1_write(fmd, req_opts->is_inbound, assoc_size, | |
1083 | hash_parms->key_len, cipher_parms->key_len, | |
1084 | false, false, | |
1085 | aead_parms->return_iv, aead_parms->ret_iv_len, | |
1086 | aead_parms->ret_iv_off, | |
1087 | cipher_parms->iv_len, hash_parms->digestsize, | |
1088 | !req_opts->bd_suppress, return_md); | |
1089 | ||
1090 | spu2_fmd_ctrl2_write(fmd, cipher_offset, hash_parms->key_len, 0, | |
1091 | cipher_parms->key_len, cipher_parms->iv_len); | |
1092 | ||
1093 | spu2_fmd_ctrl3_write(fmd, payload_len); | |
1094 | ||
1095 | ptr = (u8 *)(fmd + 1); | |
1096 | buf_len = sizeof(struct SPU2_FMD); | |
1097 | ||
1098 | /* Write OMD */ | |
1099 | if (hash_parms->key_len) { | |
1100 | memcpy(ptr, hash_parms->key_buf, hash_parms->key_len); | |
1101 | ptr += hash_parms->key_len; | |
1102 | buf_len += hash_parms->key_len; | |
1103 | } | |
1104 | if (cipher_parms->key_len) { | |
1105 | memcpy(ptr, cipher_parms->key_buf, cipher_parms->key_len); | |
1106 | ptr += cipher_parms->key_len; | |
1107 | buf_len += cipher_parms->key_len; | |
1108 | } | |
1109 | if (cipher_parms->iv_len) { | |
1110 | memcpy(ptr, cipher_parms->iv_buf, cipher_parms->iv_len); | |
1111 | ptr += cipher_parms->iv_len; | |
1112 | buf_len += cipher_parms->iv_len; | |
1113 | } | |
1114 | ||
1115 | packet_dump(" SPU request header: ", spu_hdr, buf_len); | |
1116 | ||
1117 | return buf_len; | |
1118 | } | |
1119 | ||
1120 | /** | |
1121 | * spu_cipher_req_init() - Build an ablkcipher SPU2 request message header, | |
1122 | * including FMD and OMD. | |
1123 | * @spu_hdr: Location of start of SPU request (FMD field) | |
1124 | * @cipher_parms: Parameters describing cipher request | |
1125 | * | |
1126 | * Called at setkey time to initialize a msg header that can be reused for all | |
1127 | * subsequent ablkcipher requests. Construct the message starting at spu_hdr. | |
1128 | * Caller should allocate this buffer in DMA-able memory at least | |
1129 | * SPU_HEADER_ALLOC_LEN bytes long. | |
1130 | * | |
1131 | * Return: the total length of the SPU header (FMD and OMD) in bytes. 0 if an | |
1132 | * error occurs. | |
1133 | */ | |
1134 | u16 spu2_cipher_req_init(u8 *spu_hdr, struct spu_cipher_parms *cipher_parms) | |
1135 | { | |
1136 | struct SPU2_FMD *fmd; | |
1137 | u8 *omd; | |
1138 | enum spu2_cipher_type spu2_type = SPU2_CIPHER_TYPE_NONE; | |
1139 | enum spu2_cipher_mode spu2_mode; | |
1140 | int err; | |
1141 | ||
1142 | flow_log("%s()\n", __func__); | |
1143 | flow_log(" cipher alg:%u mode:%u type %u\n", cipher_parms->alg, | |
1144 | cipher_parms->mode, cipher_parms->type); | |
1145 | flow_log(" cipher_iv_len: %u\n", cipher_parms->iv_len); | |
1146 | flow_log(" key: %d\n", cipher_parms->key_len); | |
1147 | flow_dump(" key: ", cipher_parms->key_buf, cipher_parms->key_len); | |
1148 | ||
1149 | /* Convert to spu2 values */ | |
1150 | err = spu2_cipher_xlate(cipher_parms->alg, cipher_parms->mode, | |
1151 | cipher_parms->type, &spu2_type, &spu2_mode); | |
1152 | if (err) | |
1153 | return 0; | |
1154 | ||
1155 | flow_log("spu2 cipher type %s, cipher mode %s\n", | |
1156 | spu2_ciph_type_name(spu2_type), | |
1157 | spu2_ciph_mode_name(spu2_mode)); | |
1158 | ||
1159 | /* Construct the FMD header */ | |
1160 | fmd = (struct SPU2_FMD *)spu_hdr; | |
1161 | err = spu2_fmd_init(fmd, spu2_type, spu2_mode, cipher_parms->key_len, | |
1162 | cipher_parms->iv_len); | |
1163 | if (err) | |
1164 | return 0; | |
1165 | ||
1166 | /* Write cipher key to OMD */ | |
1167 | omd = (u8 *)(fmd + 1); | |
1168 | if (cipher_parms->key_buf && cipher_parms->key_len) | |
1169 | memcpy(omd, cipher_parms->key_buf, cipher_parms->key_len); | |
1170 | ||
1171 | packet_dump(" SPU request header: ", spu_hdr, | |
1172 | FMD_SIZE + cipher_parms->key_len + cipher_parms->iv_len); | |
1173 | ||
1174 | return FMD_SIZE + cipher_parms->key_len + cipher_parms->iv_len; | |
1175 | } | |
1176 | ||
1177 | /** | |
1178 | * spu_cipher_req_finish() - Finish building a SPU request message header for a | |
1179 | * block cipher request. | |
1180 | * @spu_hdr: Start of the request message header (MH field) | |
1181 | * @spu_req_hdr_len: Length in bytes of the SPU request header | |
1182 | * @isInbound: 0 encrypt, 1 decrypt | |
1183 | * @cipher_parms: Parameters describing cipher operation to be performed | |
1184 | * @update_key: If true, rewrite the cipher key in SCTX | |
1185 | * @data_size: Length of the data in the BD field | |
1186 | * | |
1187 | * Assumes much of the header was already filled in at setkey() time in | |
1188 | * spu_cipher_req_init(). | |
1189 | * spu_cipher_req_init() fills in the encryption key. For RC4, when submitting a | |
1190 | * request for a non-first chunk, we use the 260-byte SUPDT field from the | |
1191 | * previous response as the key. update_key is true for this case. Unused in all | |
1192 | * other cases. | |
1193 | */ | |
1194 | void spu2_cipher_req_finish(u8 *spu_hdr, | |
1195 | u16 spu_req_hdr_len, | |
1196 | unsigned int is_inbound, | |
1197 | struct spu_cipher_parms *cipher_parms, | |
1198 | bool update_key, | |
1199 | unsigned int data_size) | |
1200 | { | |
1201 | struct SPU2_FMD *fmd; | |
1202 | u8 *omd; /* start of optional metadata */ | |
1203 | u64 ctrl0; | |
1204 | u64 ctrl3; | |
1205 | ||
1206 | flow_log("%s()\n", __func__); | |
1207 | flow_log(" in: %u\n", is_inbound); | |
1208 | flow_log(" cipher alg: %u, cipher_type: %u\n", cipher_parms->alg, | |
1209 | cipher_parms->type); | |
1210 | if (update_key) { | |
1211 | flow_log(" cipher key len: %u\n", cipher_parms->key_len); | |
1212 | flow_dump(" key: ", cipher_parms->key_buf, | |
1213 | cipher_parms->key_len); | |
1214 | } | |
1215 | flow_log(" iv len: %d\n", cipher_parms->iv_len); | |
1216 | flow_dump(" iv: ", cipher_parms->iv_buf, cipher_parms->iv_len); | |
1217 | flow_log(" data_size: %u\n", data_size); | |
1218 | ||
1219 | fmd = (struct SPU2_FMD *)spu_hdr; | |
1220 | omd = (u8 *)(fmd + 1); | |
1221 | ||
1222 | /* | |
1223 | * FMD ctrl0 was initialized at setkey time. update it to indicate | |
1224 | * whether we are encrypting or decrypting. | |
1225 | */ | |
1226 | ctrl0 = le64_to_cpu(fmd->ctrl0); | |
1227 | if (is_inbound) | |
1228 | ctrl0 &= ~SPU2_CIPH_ENCRYPT_EN; /* decrypt */ | |
1229 | else | |
1230 | ctrl0 |= SPU2_CIPH_ENCRYPT_EN; /* encrypt */ | |
1231 | fmd->ctrl0 = cpu_to_le64(ctrl0); | |
1232 | ||
1233 | if (cipher_parms->alg && cipher_parms->iv_buf && cipher_parms->iv_len) { | |
1234 | /* cipher iv provided so put it in here */ | |
1235 | memcpy(omd + cipher_parms->key_len, cipher_parms->iv_buf, | |
1236 | cipher_parms->iv_len); | |
1237 | } | |
1238 | ||
1239 | ctrl3 = le64_to_cpu(fmd->ctrl3); | |
1240 | data_size &= SPU2_PL_LEN; | |
1241 | ctrl3 |= data_size; | |
1242 | fmd->ctrl3 = cpu_to_le64(ctrl3); | |
1243 | ||
1244 | packet_dump(" SPU request header: ", spu_hdr, spu_req_hdr_len); | |
1245 | } | |
1246 | ||
1247 | /** | |
1248 | * spu_request_pad() - Create pad bytes at the end of the data. | |
1249 | * @pad_start: Start of buffer where pad bytes are to be written | |
1250 | * @gcm_padding: Length of GCM padding, in bytes | |
1251 | * @hash_pad_len: Number of bytes of padding extend data to full block | |
1252 | * @auth_alg: Authentication algorithm | |
1253 | * @auth_mode: Authentication mode | |
1254 | * @total_sent: Length inserted at end of hash pad | |
1255 | * @status_padding: Number of bytes of padding to align STATUS word | |
1256 | * | |
1257 | * There may be three forms of pad: | |
1258 | * 1. GCM pad - for GCM mode ciphers, pad to 16-byte alignment | |
1259 | * 2. hash pad - pad to a block length, with 0x80 data terminator and | |
1260 | * size at the end | |
1261 | * 3. STAT pad - to ensure the STAT field is 4-byte aligned | |
1262 | */ | |
1263 | void spu2_request_pad(u8 *pad_start, u32 gcm_padding, u32 hash_pad_len, | |
1264 | enum hash_alg auth_alg, enum hash_mode auth_mode, | |
1265 | unsigned int total_sent, u32 status_padding) | |
1266 | { | |
1267 | u8 *ptr = pad_start; | |
1268 | ||
1269 | /* fix data alignent for GCM */ | |
1270 | if (gcm_padding > 0) { | |
1271 | flow_log(" GCM: padding to 16 byte alignment: %u bytes\n", | |
1272 | gcm_padding); | |
1273 | memset(ptr, 0, gcm_padding); | |
1274 | ptr += gcm_padding; | |
1275 | } | |
1276 | ||
1277 | if (hash_pad_len > 0) { | |
1278 | /* clear the padding section */ | |
1279 | memset(ptr, 0, hash_pad_len); | |
1280 | ||
1281 | /* terminate the data */ | |
1282 | *ptr = 0x80; | |
1283 | ptr += (hash_pad_len - sizeof(u64)); | |
1284 | ||
1285 | /* add the size at the end as required per alg */ | |
1286 | if (auth_alg == HASH_ALG_MD5) | |
1287 | *(u64 *)ptr = cpu_to_le64((u64)total_sent * 8); | |
1288 | else /* SHA1, SHA2-224, SHA2-256 */ | |
1289 | *(u64 *)ptr = cpu_to_be64((u64)total_sent * 8); | |
1290 | ptr += sizeof(u64); | |
1291 | } | |
1292 | ||
1293 | /* pad to a 4byte alignment for STAT */ | |
1294 | if (status_padding > 0) { | |
1295 | flow_log(" STAT: padding to 4 byte alignment: %u bytes\n", | |
1296 | status_padding); | |
1297 | ||
1298 | memset(ptr, 0, status_padding); | |
1299 | ptr += status_padding; | |
1300 | } | |
1301 | } | |
1302 | ||
1303 | /** | |
1304 | * spu2_xts_tweak_in_payload() - Indicate that SPU2 does NOT place the XTS | |
1305 | * tweak field in the packet payload (it uses IV instead) | |
1306 | * | |
1307 | * Return: 0 | |
1308 | */ | |
1309 | u8 spu2_xts_tweak_in_payload(void) | |
1310 | { | |
1311 | return 0; | |
1312 | } | |
1313 | ||
1314 | /** | |
1315 | * spu2_tx_status_len() - Return the length of the STATUS field in a SPU | |
1316 | * response message. | |
1317 | * | |
1318 | * Return: Length of STATUS field in bytes. | |
1319 | */ | |
1320 | u8 spu2_tx_status_len(void) | |
1321 | { | |
1322 | return SPU2_TX_STATUS_LEN; | |
1323 | } | |
1324 | ||
1325 | /** | |
1326 | * spu2_rx_status_len() - Return the length of the STATUS field in a SPU | |
1327 | * response message. | |
1328 | * | |
1329 | * Return: Length of STATUS field in bytes. | |
1330 | */ | |
1331 | u8 spu2_rx_status_len(void) | |
1332 | { | |
1333 | return SPU2_RX_STATUS_LEN; | |
1334 | } | |
1335 | ||
1336 | /** | |
1337 | * spu_status_process() - Process the status from a SPU response message. | |
1338 | * @statp: start of STATUS word | |
1339 | * | |
1340 | * Return: 0 - if status is good and response should be processed | |
1341 | * !0 - status indicates an error and response is invalid | |
1342 | */ | |
1343 | int spu2_status_process(u8 *statp) | |
1344 | { | |
1345 | /* SPU2 status is 2 bytes by default - SPU_RX_STATUS_LEN */ | |
1346 | u16 status = le16_to_cpu(*(__le16 *)statp); | |
1347 | ||
1348 | if (status == 0) | |
1349 | return 0; | |
1350 | ||
1351 | flow_log("rx status is %#x\n", status); | |
1352 | if (status == SPU2_INVALID_ICV) | |
1353 | return SPU_INVALID_ICV; | |
1354 | ||
1355 | return -EBADMSG; | |
1356 | } | |
1357 | ||
1358 | /** | |
1359 | * spu2_ccm_update_iv() - Update the IV as per the requirements for CCM mode. | |
1360 | * | |
1361 | * @digestsize: Digest size of this request | |
1362 | * @cipher_parms: (pointer to) cipher parmaeters, includes IV buf & IV len | |
1363 | * @assoclen: Length of AAD data | |
1364 | * @chunksize: length of input data to be sent in this req | |
1365 | * @is_encrypt: true if this is an output/encrypt operation | |
1366 | * @is_esp: true if this is an ESP / RFC4309 operation | |
1367 | * | |
1368 | */ | |
1369 | void spu2_ccm_update_iv(unsigned int digestsize, | |
1370 | struct spu_cipher_parms *cipher_parms, | |
1371 | unsigned int assoclen, unsigned int chunksize, | |
1372 | bool is_encrypt, bool is_esp) | |
1373 | { | |
1374 | int L; /* size of length field, in bytes */ | |
1375 | ||
1376 | /* | |
1377 | * In RFC4309 mode, L is fixed at 4 bytes; otherwise, IV from | |
1378 | * testmgr contains (L-1) in bottom 3 bits of first byte, | |
1379 | * per RFC 3610. | |
1380 | */ | |
1381 | if (is_esp) | |
1382 | L = CCM_ESP_L_VALUE; | |
1383 | else | |
1384 | L = ((cipher_parms->iv_buf[0] & CCM_B0_L_PRIME) >> | |
1385 | CCM_B0_L_PRIME_SHIFT) + 1; | |
1386 | ||
1387 | /* SPU2 doesn't want these length bytes nor the first byte... */ | |
1388 | cipher_parms->iv_len -= (1 + L); | |
1389 | memmove(cipher_parms->iv_buf, &cipher_parms->iv_buf[1], | |
1390 | cipher_parms->iv_len); | |
1391 | } | |
1392 | ||
1393 | /** | |
1394 | * spu2_wordalign_padlen() - SPU2 does not require padding. | |
1395 | * @data_size: length of data field in bytes | |
1396 | * | |
1397 | * Return: length of status field padding, in bytes (always 0 on SPU2) | |
1398 | */ | |
1399 | u32 spu2_wordalign_padlen(u32 data_size) | |
1400 | { | |
1401 | return 0; | |
1402 | } |