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