Merge tag 'acpi-5.1-rc4' of git://git.kernel.org/pub/scm/linux/kernel/git/rafael...
[sfrench/cifs-2.6.git] / net / xfrm / xfrm_algo.c
1 /*
2  * xfrm algorithm interface
3  *
4  * Copyright (c) 2002 James Morris <jmorris@intercode.com.au>
5  *
6  * This program is free software; you can redistribute it and/or modify it
7  * under the terms of the GNU General Public License as published by the Free
8  * Software Foundation; either version 2 of the License, or (at your option)
9  * any later version.
10  */
11
12 #include <crypto/hash.h>
13 #include <crypto/skcipher.h>
14 #include <linux/module.h>
15 #include <linux/kernel.h>
16 #include <linux/pfkeyv2.h>
17 #include <linux/crypto.h>
18 #include <linux/scatterlist.h>
19 #include <net/xfrm.h>
20 #if IS_ENABLED(CONFIG_INET_ESP) || IS_ENABLED(CONFIG_INET6_ESP)
21 #include <net/esp.h>
22 #endif
23
24 /*
25  * Algorithms supported by IPsec.  These entries contain properties which
26  * are used in key negotiation and xfrm processing, and are used to verify
27  * that instantiated crypto transforms have correct parameters for IPsec
28  * purposes.
29  */
30 static struct xfrm_algo_desc aead_list[] = {
31 {
32         .name = "rfc4106(gcm(aes))",
33
34         .uinfo = {
35                 .aead = {
36                         .geniv = "seqiv",
37                         .icv_truncbits = 64,
38                 }
39         },
40
41         .pfkey_supported = 1,
42
43         .desc = {
44                 .sadb_alg_id = SADB_X_EALG_AES_GCM_ICV8,
45                 .sadb_alg_ivlen = 8,
46                 .sadb_alg_minbits = 128,
47                 .sadb_alg_maxbits = 256
48         }
49 },
50 {
51         .name = "rfc4106(gcm(aes))",
52
53         .uinfo = {
54                 .aead = {
55                         .geniv = "seqiv",
56                         .icv_truncbits = 96,
57                 }
58         },
59
60         .pfkey_supported = 1,
61
62         .desc = {
63                 .sadb_alg_id = SADB_X_EALG_AES_GCM_ICV12,
64                 .sadb_alg_ivlen = 8,
65                 .sadb_alg_minbits = 128,
66                 .sadb_alg_maxbits = 256
67         }
68 },
69 {
70         .name = "rfc4106(gcm(aes))",
71
72         .uinfo = {
73                 .aead = {
74                         .geniv = "seqiv",
75                         .icv_truncbits = 128,
76                 }
77         },
78
79         .pfkey_supported = 1,
80
81         .desc = {
82                 .sadb_alg_id = SADB_X_EALG_AES_GCM_ICV16,
83                 .sadb_alg_ivlen = 8,
84                 .sadb_alg_minbits = 128,
85                 .sadb_alg_maxbits = 256
86         }
87 },
88 {
89         .name = "rfc4309(ccm(aes))",
90
91         .uinfo = {
92                 .aead = {
93                         .geniv = "seqiv",
94                         .icv_truncbits = 64,
95                 }
96         },
97
98         .pfkey_supported = 1,
99
100         .desc = {
101                 .sadb_alg_id = SADB_X_EALG_AES_CCM_ICV8,
102                 .sadb_alg_ivlen = 8,
103                 .sadb_alg_minbits = 128,
104                 .sadb_alg_maxbits = 256
105         }
106 },
107 {
108         .name = "rfc4309(ccm(aes))",
109
110         .uinfo = {
111                 .aead = {
112                         .geniv = "seqiv",
113                         .icv_truncbits = 96,
114                 }
115         },
116
117         .pfkey_supported = 1,
118
119         .desc = {
120                 .sadb_alg_id = SADB_X_EALG_AES_CCM_ICV12,
121                 .sadb_alg_ivlen = 8,
122                 .sadb_alg_minbits = 128,
123                 .sadb_alg_maxbits = 256
124         }
125 },
126 {
127         .name = "rfc4309(ccm(aes))",
128
129         .uinfo = {
130                 .aead = {
131                         .geniv = "seqiv",
132                         .icv_truncbits = 128,
133                 }
134         },
135
136         .pfkey_supported = 1,
137
138         .desc = {
139                 .sadb_alg_id = SADB_X_EALG_AES_CCM_ICV16,
140                 .sadb_alg_ivlen = 8,
141                 .sadb_alg_minbits = 128,
142                 .sadb_alg_maxbits = 256
143         }
144 },
145 {
146         .name = "rfc4543(gcm(aes))",
147
148         .uinfo = {
149                 .aead = {
150                         .geniv = "seqiv",
151                         .icv_truncbits = 128,
152                 }
153         },
154
155         .pfkey_supported = 1,
156
157         .desc = {
158                 .sadb_alg_id = SADB_X_EALG_NULL_AES_GMAC,
159                 .sadb_alg_ivlen = 8,
160                 .sadb_alg_minbits = 128,
161                 .sadb_alg_maxbits = 256
162         }
163 },
164 {
165         .name = "rfc7539esp(chacha20,poly1305)",
166
167         .uinfo = {
168                 .aead = {
169                         .geniv = "seqiv",
170                         .icv_truncbits = 128,
171                 }
172         },
173
174         .pfkey_supported = 0,
175 },
176 };
177
178 static struct xfrm_algo_desc aalg_list[] = {
179 {
180         .name = "digest_null",
181
182         .uinfo = {
183                 .auth = {
184                         .icv_truncbits = 0,
185                         .icv_fullbits = 0,
186                 }
187         },
188
189         .pfkey_supported = 1,
190
191         .desc = {
192                 .sadb_alg_id = SADB_X_AALG_NULL,
193                 .sadb_alg_ivlen = 0,
194                 .sadb_alg_minbits = 0,
195                 .sadb_alg_maxbits = 0
196         }
197 },
198 {
199         .name = "hmac(md5)",
200         .compat = "md5",
201
202         .uinfo = {
203                 .auth = {
204                         .icv_truncbits = 96,
205                         .icv_fullbits = 128,
206                 }
207         },
208
209         .pfkey_supported = 1,
210
211         .desc = {
212                 .sadb_alg_id = SADB_AALG_MD5HMAC,
213                 .sadb_alg_ivlen = 0,
214                 .sadb_alg_minbits = 128,
215                 .sadb_alg_maxbits = 128
216         }
217 },
218 {
219         .name = "hmac(sha1)",
220         .compat = "sha1",
221
222         .uinfo = {
223                 .auth = {
224                         .icv_truncbits = 96,
225                         .icv_fullbits = 160,
226                 }
227         },
228
229         .pfkey_supported = 1,
230
231         .desc = {
232                 .sadb_alg_id = SADB_AALG_SHA1HMAC,
233                 .sadb_alg_ivlen = 0,
234                 .sadb_alg_minbits = 160,
235                 .sadb_alg_maxbits = 160
236         }
237 },
238 {
239         .name = "hmac(sha256)",
240         .compat = "sha256",
241
242         .uinfo = {
243                 .auth = {
244                         .icv_truncbits = 96,
245                         .icv_fullbits = 256,
246                 }
247         },
248
249         .pfkey_supported = 1,
250
251         .desc = {
252                 .sadb_alg_id = SADB_X_AALG_SHA2_256HMAC,
253                 .sadb_alg_ivlen = 0,
254                 .sadb_alg_minbits = 256,
255                 .sadb_alg_maxbits = 256
256         }
257 },
258 {
259         .name = "hmac(sha384)",
260
261         .uinfo = {
262                 .auth = {
263                         .icv_truncbits = 192,
264                         .icv_fullbits = 384,
265                 }
266         },
267
268         .pfkey_supported = 1,
269
270         .desc = {
271                 .sadb_alg_id = SADB_X_AALG_SHA2_384HMAC,
272                 .sadb_alg_ivlen = 0,
273                 .sadb_alg_minbits = 384,
274                 .sadb_alg_maxbits = 384
275         }
276 },
277 {
278         .name = "hmac(sha512)",
279
280         .uinfo = {
281                 .auth = {
282                         .icv_truncbits = 256,
283                         .icv_fullbits = 512,
284                 }
285         },
286
287         .pfkey_supported = 1,
288
289         .desc = {
290                 .sadb_alg_id = SADB_X_AALG_SHA2_512HMAC,
291                 .sadb_alg_ivlen = 0,
292                 .sadb_alg_minbits = 512,
293                 .sadb_alg_maxbits = 512
294         }
295 },
296 {
297         .name = "hmac(rmd160)",
298         .compat = "rmd160",
299
300         .uinfo = {
301                 .auth = {
302                         .icv_truncbits = 96,
303                         .icv_fullbits = 160,
304                 }
305         },
306
307         .pfkey_supported = 1,
308
309         .desc = {
310                 .sadb_alg_id = SADB_X_AALG_RIPEMD160HMAC,
311                 .sadb_alg_ivlen = 0,
312                 .sadb_alg_minbits = 160,
313                 .sadb_alg_maxbits = 160
314         }
315 },
316 {
317         .name = "xcbc(aes)",
318
319         .uinfo = {
320                 .auth = {
321                         .icv_truncbits = 96,
322                         .icv_fullbits = 128,
323                 }
324         },
325
326         .pfkey_supported = 1,
327
328         .desc = {
329                 .sadb_alg_id = SADB_X_AALG_AES_XCBC_MAC,
330                 .sadb_alg_ivlen = 0,
331                 .sadb_alg_minbits = 128,
332                 .sadb_alg_maxbits = 128
333         }
334 },
335 {
336         /* rfc4494 */
337         .name = "cmac(aes)",
338
339         .uinfo = {
340                 .auth = {
341                         .icv_truncbits = 96,
342                         .icv_fullbits = 128,
343                 }
344         },
345
346         .pfkey_supported = 0,
347 },
348 };
349
350 static struct xfrm_algo_desc ealg_list[] = {
351 {
352         .name = "ecb(cipher_null)",
353         .compat = "cipher_null",
354
355         .uinfo = {
356                 .encr = {
357                         .blockbits = 8,
358                         .defkeybits = 0,
359                 }
360         },
361
362         .pfkey_supported = 1,
363
364         .desc = {
365                 .sadb_alg_id =  SADB_EALG_NULL,
366                 .sadb_alg_ivlen = 0,
367                 .sadb_alg_minbits = 0,
368                 .sadb_alg_maxbits = 0
369         }
370 },
371 {
372         .name = "cbc(des)",
373         .compat = "des",
374
375         .uinfo = {
376                 .encr = {
377                         .geniv = "echainiv",
378                         .blockbits = 64,
379                         .defkeybits = 64,
380                 }
381         },
382
383         .pfkey_supported = 1,
384
385         .desc = {
386                 .sadb_alg_id = SADB_EALG_DESCBC,
387                 .sadb_alg_ivlen = 8,
388                 .sadb_alg_minbits = 64,
389                 .sadb_alg_maxbits = 64
390         }
391 },
392 {
393         .name = "cbc(des3_ede)",
394         .compat = "des3_ede",
395
396         .uinfo = {
397                 .encr = {
398                         .geniv = "echainiv",
399                         .blockbits = 64,
400                         .defkeybits = 192,
401                 }
402         },
403
404         .pfkey_supported = 1,
405
406         .desc = {
407                 .sadb_alg_id = SADB_EALG_3DESCBC,
408                 .sadb_alg_ivlen = 8,
409                 .sadb_alg_minbits = 192,
410                 .sadb_alg_maxbits = 192
411         }
412 },
413 {
414         .name = "cbc(cast5)",
415         .compat = "cast5",
416
417         .uinfo = {
418                 .encr = {
419                         .geniv = "echainiv",
420                         .blockbits = 64,
421                         .defkeybits = 128,
422                 }
423         },
424
425         .pfkey_supported = 1,
426
427         .desc = {
428                 .sadb_alg_id = SADB_X_EALG_CASTCBC,
429                 .sadb_alg_ivlen = 8,
430                 .sadb_alg_minbits = 40,
431                 .sadb_alg_maxbits = 128
432         }
433 },
434 {
435         .name = "cbc(blowfish)",
436         .compat = "blowfish",
437
438         .uinfo = {
439                 .encr = {
440                         .geniv = "echainiv",
441                         .blockbits = 64,
442                         .defkeybits = 128,
443                 }
444         },
445
446         .pfkey_supported = 1,
447
448         .desc = {
449                 .sadb_alg_id = SADB_X_EALG_BLOWFISHCBC,
450                 .sadb_alg_ivlen = 8,
451                 .sadb_alg_minbits = 40,
452                 .sadb_alg_maxbits = 448
453         }
454 },
455 {
456         .name = "cbc(aes)",
457         .compat = "aes",
458
459         .uinfo = {
460                 .encr = {
461                         .geniv = "echainiv",
462                         .blockbits = 128,
463                         .defkeybits = 128,
464                 }
465         },
466
467         .pfkey_supported = 1,
468
469         .desc = {
470                 .sadb_alg_id = SADB_X_EALG_AESCBC,
471                 .sadb_alg_ivlen = 8,
472                 .sadb_alg_minbits = 128,
473                 .sadb_alg_maxbits = 256
474         }
475 },
476 {
477         .name = "cbc(serpent)",
478         .compat = "serpent",
479
480         .uinfo = {
481                 .encr = {
482                         .geniv = "echainiv",
483                         .blockbits = 128,
484                         .defkeybits = 128,
485                 }
486         },
487
488         .pfkey_supported = 1,
489
490         .desc = {
491                 .sadb_alg_id = SADB_X_EALG_SERPENTCBC,
492                 .sadb_alg_ivlen = 8,
493                 .sadb_alg_minbits = 128,
494                 .sadb_alg_maxbits = 256,
495         }
496 },
497 {
498         .name = "cbc(camellia)",
499         .compat = "camellia",
500
501         .uinfo = {
502                 .encr = {
503                         .geniv = "echainiv",
504                         .blockbits = 128,
505                         .defkeybits = 128,
506                 }
507         },
508
509         .pfkey_supported = 1,
510
511         .desc = {
512                 .sadb_alg_id = SADB_X_EALG_CAMELLIACBC,
513                 .sadb_alg_ivlen = 8,
514                 .sadb_alg_minbits = 128,
515                 .sadb_alg_maxbits = 256
516         }
517 },
518 {
519         .name = "cbc(twofish)",
520         .compat = "twofish",
521
522         .uinfo = {
523                 .encr = {
524                         .geniv = "echainiv",
525                         .blockbits = 128,
526                         .defkeybits = 128,
527                 }
528         },
529
530         .pfkey_supported = 1,
531
532         .desc = {
533                 .sadb_alg_id = SADB_X_EALG_TWOFISHCBC,
534                 .sadb_alg_ivlen = 8,
535                 .sadb_alg_minbits = 128,
536                 .sadb_alg_maxbits = 256
537         }
538 },
539 {
540         .name = "rfc3686(ctr(aes))",
541
542         .uinfo = {
543                 .encr = {
544                         .geniv = "seqiv",
545                         .blockbits = 128,
546                         .defkeybits = 160, /* 128-bit key + 32-bit nonce */
547                 }
548         },
549
550         .pfkey_supported = 1,
551
552         .desc = {
553                 .sadb_alg_id = SADB_X_EALG_AESCTR,
554                 .sadb_alg_ivlen = 8,
555                 .sadb_alg_minbits = 160,
556                 .sadb_alg_maxbits = 288
557         }
558 },
559 };
560
561 static struct xfrm_algo_desc calg_list[] = {
562 {
563         .name = "deflate",
564         .uinfo = {
565                 .comp = {
566                         .threshold = 90,
567                 }
568         },
569         .pfkey_supported = 1,
570         .desc = { .sadb_alg_id = SADB_X_CALG_DEFLATE }
571 },
572 {
573         .name = "lzs",
574         .uinfo = {
575                 .comp = {
576                         .threshold = 90,
577                 }
578         },
579         .pfkey_supported = 1,
580         .desc = { .sadb_alg_id = SADB_X_CALG_LZS }
581 },
582 {
583         .name = "lzjh",
584         .uinfo = {
585                 .comp = {
586                         .threshold = 50,
587                 }
588         },
589         .pfkey_supported = 1,
590         .desc = { .sadb_alg_id = SADB_X_CALG_LZJH }
591 },
592 };
593
594 static inline int aalg_entries(void)
595 {
596         return ARRAY_SIZE(aalg_list);
597 }
598
599 static inline int ealg_entries(void)
600 {
601         return ARRAY_SIZE(ealg_list);
602 }
603
604 static inline int calg_entries(void)
605 {
606         return ARRAY_SIZE(calg_list);
607 }
608
609 struct xfrm_algo_list {
610         struct xfrm_algo_desc *algs;
611         int entries;
612         u32 type;
613         u32 mask;
614 };
615
616 static const struct xfrm_algo_list xfrm_aead_list = {
617         .algs = aead_list,
618         .entries = ARRAY_SIZE(aead_list),
619         .type = CRYPTO_ALG_TYPE_AEAD,
620         .mask = CRYPTO_ALG_TYPE_MASK,
621 };
622
623 static const struct xfrm_algo_list xfrm_aalg_list = {
624         .algs = aalg_list,
625         .entries = ARRAY_SIZE(aalg_list),
626         .type = CRYPTO_ALG_TYPE_HASH,
627         .mask = CRYPTO_ALG_TYPE_HASH_MASK,
628 };
629
630 static const struct xfrm_algo_list xfrm_ealg_list = {
631         .algs = ealg_list,
632         .entries = ARRAY_SIZE(ealg_list),
633         .type = CRYPTO_ALG_TYPE_BLKCIPHER,
634         .mask = CRYPTO_ALG_TYPE_BLKCIPHER_MASK,
635 };
636
637 static const struct xfrm_algo_list xfrm_calg_list = {
638         .algs = calg_list,
639         .entries = ARRAY_SIZE(calg_list),
640         .type = CRYPTO_ALG_TYPE_COMPRESS,
641         .mask = CRYPTO_ALG_TYPE_MASK,
642 };
643
644 static struct xfrm_algo_desc *xfrm_find_algo(
645         const struct xfrm_algo_list *algo_list,
646         int match(const struct xfrm_algo_desc *entry, const void *data),
647         const void *data, int probe)
648 {
649         struct xfrm_algo_desc *list = algo_list->algs;
650         int i, status;
651
652         for (i = 0; i < algo_list->entries; i++) {
653                 if (!match(list + i, data))
654                         continue;
655
656                 if (list[i].available)
657                         return &list[i];
658
659                 if (!probe)
660                         break;
661
662                 status = crypto_has_alg(list[i].name, algo_list->type,
663                                         algo_list->mask);
664                 if (!status)
665                         break;
666
667                 list[i].available = status;
668                 return &list[i];
669         }
670         return NULL;
671 }
672
673 static int xfrm_alg_id_match(const struct xfrm_algo_desc *entry,
674                              const void *data)
675 {
676         return entry->desc.sadb_alg_id == (unsigned long)data;
677 }
678
679 struct xfrm_algo_desc *xfrm_aalg_get_byid(int alg_id)
680 {
681         return xfrm_find_algo(&xfrm_aalg_list, xfrm_alg_id_match,
682                               (void *)(unsigned long)alg_id, 1);
683 }
684 EXPORT_SYMBOL_GPL(xfrm_aalg_get_byid);
685
686 struct xfrm_algo_desc *xfrm_ealg_get_byid(int alg_id)
687 {
688         return xfrm_find_algo(&xfrm_ealg_list, xfrm_alg_id_match,
689                               (void *)(unsigned long)alg_id, 1);
690 }
691 EXPORT_SYMBOL_GPL(xfrm_ealg_get_byid);
692
693 struct xfrm_algo_desc *xfrm_calg_get_byid(int alg_id)
694 {
695         return xfrm_find_algo(&xfrm_calg_list, xfrm_alg_id_match,
696                               (void *)(unsigned long)alg_id, 1);
697 }
698 EXPORT_SYMBOL_GPL(xfrm_calg_get_byid);
699
700 static int xfrm_alg_name_match(const struct xfrm_algo_desc *entry,
701                                const void *data)
702 {
703         const char *name = data;
704
705         return name && (!strcmp(name, entry->name) ||
706                         (entry->compat && !strcmp(name, entry->compat)));
707 }
708
709 struct xfrm_algo_desc *xfrm_aalg_get_byname(const char *name, int probe)
710 {
711         return xfrm_find_algo(&xfrm_aalg_list, xfrm_alg_name_match, name,
712                               probe);
713 }
714 EXPORT_SYMBOL_GPL(xfrm_aalg_get_byname);
715
716 struct xfrm_algo_desc *xfrm_ealg_get_byname(const char *name, int probe)
717 {
718         return xfrm_find_algo(&xfrm_ealg_list, xfrm_alg_name_match, name,
719                               probe);
720 }
721 EXPORT_SYMBOL_GPL(xfrm_ealg_get_byname);
722
723 struct xfrm_algo_desc *xfrm_calg_get_byname(const char *name, int probe)
724 {
725         return xfrm_find_algo(&xfrm_calg_list, xfrm_alg_name_match, name,
726                               probe);
727 }
728 EXPORT_SYMBOL_GPL(xfrm_calg_get_byname);
729
730 struct xfrm_aead_name {
731         const char *name;
732         int icvbits;
733 };
734
735 static int xfrm_aead_name_match(const struct xfrm_algo_desc *entry,
736                                 const void *data)
737 {
738         const struct xfrm_aead_name *aead = data;
739         const char *name = aead->name;
740
741         return aead->icvbits == entry->uinfo.aead.icv_truncbits && name &&
742                !strcmp(name, entry->name);
743 }
744
745 struct xfrm_algo_desc *xfrm_aead_get_byname(const char *name, int icv_len, int probe)
746 {
747         struct xfrm_aead_name data = {
748                 .name = name,
749                 .icvbits = icv_len,
750         };
751
752         return xfrm_find_algo(&xfrm_aead_list, xfrm_aead_name_match, &data,
753                               probe);
754 }
755 EXPORT_SYMBOL_GPL(xfrm_aead_get_byname);
756
757 struct xfrm_algo_desc *xfrm_aalg_get_byidx(unsigned int idx)
758 {
759         if (idx >= aalg_entries())
760                 return NULL;
761
762         return &aalg_list[idx];
763 }
764 EXPORT_SYMBOL_GPL(xfrm_aalg_get_byidx);
765
766 struct xfrm_algo_desc *xfrm_ealg_get_byidx(unsigned int idx)
767 {
768         if (idx >= ealg_entries())
769                 return NULL;
770
771         return &ealg_list[idx];
772 }
773 EXPORT_SYMBOL_GPL(xfrm_ealg_get_byidx);
774
775 /*
776  * Probe for the availability of crypto algorithms, and set the available
777  * flag for any algorithms found on the system.  This is typically called by
778  * pfkey during userspace SA add, update or register.
779  */
780 void xfrm_probe_algs(void)
781 {
782         int i, status;
783
784         BUG_ON(in_softirq());
785
786         for (i = 0; i < aalg_entries(); i++) {
787                 status = crypto_has_ahash(aalg_list[i].name, 0, 0);
788                 if (aalg_list[i].available != status)
789                         aalg_list[i].available = status;
790         }
791
792         for (i = 0; i < ealg_entries(); i++) {
793                 status = crypto_has_skcipher(ealg_list[i].name, 0, 0);
794                 if (ealg_list[i].available != status)
795                         ealg_list[i].available = status;
796         }
797
798         for (i = 0; i < calg_entries(); i++) {
799                 status = crypto_has_comp(calg_list[i].name, 0,
800                                          CRYPTO_ALG_ASYNC);
801                 if (calg_list[i].available != status)
802                         calg_list[i].available = status;
803         }
804 }
805 EXPORT_SYMBOL_GPL(xfrm_probe_algs);
806
807 int xfrm_count_pfkey_auth_supported(void)
808 {
809         int i, n;
810
811         for (i = 0, n = 0; i < aalg_entries(); i++)
812                 if (aalg_list[i].available && aalg_list[i].pfkey_supported)
813                         n++;
814         return n;
815 }
816 EXPORT_SYMBOL_GPL(xfrm_count_pfkey_auth_supported);
817
818 int xfrm_count_pfkey_enc_supported(void)
819 {
820         int i, n;
821
822         for (i = 0, n = 0; i < ealg_entries(); i++)
823                 if (ealg_list[i].available && ealg_list[i].pfkey_supported)
824                         n++;
825         return n;
826 }
827 EXPORT_SYMBOL_GPL(xfrm_count_pfkey_enc_supported);
828
829 MODULE_LICENSE("GPL");