[CRYPTO] users: Use crypto_comp and crypto_has_*
[linux-3.10.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 <linux/module.h>
13 #include <linux/kernel.h>
14 #include <linux/pfkeyv2.h>
15 #include <linux/crypto.h>
16 #include <net/xfrm.h>
17 #if defined(CONFIG_INET_AH) || defined(CONFIG_INET_AH_MODULE) || defined(CONFIG_INET6_AH) || defined(CONFIG_INET6_AH_MODULE)
18 #include <net/ah.h>
19 #endif
20 #if defined(CONFIG_INET_ESP) || defined(CONFIG_INET_ESP_MODULE) || defined(CONFIG_INET6_ESP) || defined(CONFIG_INET6_ESP_MODULE)
21 #include <net/esp.h>
22 #endif
23 #include <asm/scatterlist.h>
24
25 /*
26  * Algorithms supported by IPsec.  These entries contain properties which
27  * are used in key negotiation and xfrm processing, and are used to verify
28  * that instantiated crypto transforms have correct parameters for IPsec
29  * purposes.
30  */
31 static struct xfrm_algo_desc aalg_list[] = {
32 {
33         .name = "hmac(digest_null)",
34         .compat = "digest_null",
35         
36         .uinfo = {
37                 .auth = {
38                         .icv_truncbits = 0,
39                         .icv_fullbits = 0,
40                 }
41         },
42         
43         .desc = {
44                 .sadb_alg_id = SADB_X_AALG_NULL,
45                 .sadb_alg_ivlen = 0,
46                 .sadb_alg_minbits = 0,
47                 .sadb_alg_maxbits = 0
48         }
49 },
50 {
51         .name = "hmac(md5)",
52         .compat = "md5",
53
54         .uinfo = {
55                 .auth = {
56                         .icv_truncbits = 96,
57                         .icv_fullbits = 128,
58                 }
59         },
60         
61         .desc = {
62                 .sadb_alg_id = SADB_AALG_MD5HMAC,
63                 .sadb_alg_ivlen = 0,
64                 .sadb_alg_minbits = 128,
65                 .sadb_alg_maxbits = 128
66         }
67 },
68 {
69         .name = "hmac(sha1)",
70         .compat = "sha1",
71
72         .uinfo = {
73                 .auth = {
74                         .icv_truncbits = 96,
75                         .icv_fullbits = 160,
76                 }
77         },
78
79         .desc = {
80                 .sadb_alg_id = SADB_AALG_SHA1HMAC,
81                 .sadb_alg_ivlen = 0,
82                 .sadb_alg_minbits = 160,
83                 .sadb_alg_maxbits = 160
84         }
85 },
86 {
87         .name = "hmac(sha256)",
88         .compat = "sha256",
89
90         .uinfo = {
91                 .auth = {
92                         .icv_truncbits = 96,
93                         .icv_fullbits = 256,
94                 }
95         },
96
97         .desc = {
98                 .sadb_alg_id = SADB_X_AALG_SHA2_256HMAC,
99                 .sadb_alg_ivlen = 0,
100                 .sadb_alg_minbits = 256,
101                 .sadb_alg_maxbits = 256
102         }
103 },
104 {
105         .name = "hmac(ripemd160)",
106         .compat = "ripemd160",
107
108         .uinfo = {
109                 .auth = {
110                         .icv_truncbits = 96,
111                         .icv_fullbits = 160,
112                 }
113         },
114
115         .desc = {
116                 .sadb_alg_id = SADB_X_AALG_RIPEMD160HMAC,
117                 .sadb_alg_ivlen = 0,
118                 .sadb_alg_minbits = 160,
119                 .sadb_alg_maxbits = 160
120         }
121 },
122 };
123
124 static struct xfrm_algo_desc ealg_list[] = {
125 {
126         .name = "ecb(cipher_null)",
127         .compat = "cipher_null",
128         
129         .uinfo = {
130                 .encr = {
131                         .blockbits = 8,
132                         .defkeybits = 0,
133                 }
134         },
135         
136         .desc = {
137                 .sadb_alg_id =  SADB_EALG_NULL,
138                 .sadb_alg_ivlen = 0,
139                 .sadb_alg_minbits = 0,
140                 .sadb_alg_maxbits = 0
141         }
142 },
143 {
144         .name = "cbc(des)",
145         .compat = "des",
146
147         .uinfo = {
148                 .encr = {
149                         .blockbits = 64,
150                         .defkeybits = 64,
151                 }
152         },
153
154         .desc = {
155                 .sadb_alg_id = SADB_EALG_DESCBC,
156                 .sadb_alg_ivlen = 8,
157                 .sadb_alg_minbits = 64,
158                 .sadb_alg_maxbits = 64
159         }
160 },
161 {
162         .name = "cbc(des3_ede)",
163         .compat = "des3_ede",
164
165         .uinfo = {
166                 .encr = {
167                         .blockbits = 64,
168                         .defkeybits = 192,
169                 }
170         },
171
172         .desc = {
173                 .sadb_alg_id = SADB_EALG_3DESCBC,
174                 .sadb_alg_ivlen = 8,
175                 .sadb_alg_minbits = 192,
176                 .sadb_alg_maxbits = 192
177         }
178 },
179 {
180         .name = "cbc(cast128)",
181         .compat = "cast128",
182
183         .uinfo = {
184                 .encr = {
185                         .blockbits = 64,
186                         .defkeybits = 128,
187                 }
188         },
189
190         .desc = {
191                 .sadb_alg_id = SADB_X_EALG_CASTCBC,
192                 .sadb_alg_ivlen = 8,
193                 .sadb_alg_minbits = 40,
194                 .sadb_alg_maxbits = 128
195         }
196 },
197 {
198         .name = "cbc(blowfish)",
199         .compat = "blowfish",
200
201         .uinfo = {
202                 .encr = {
203                         .blockbits = 64,
204                         .defkeybits = 128,
205                 }
206         },
207
208         .desc = {
209                 .sadb_alg_id = SADB_X_EALG_BLOWFISHCBC,
210                 .sadb_alg_ivlen = 8,
211                 .sadb_alg_minbits = 40,
212                 .sadb_alg_maxbits = 448
213         }
214 },
215 {
216         .name = "cbc(aes)",
217         .compat = "aes",
218
219         .uinfo = {
220                 .encr = {
221                         .blockbits = 128,
222                         .defkeybits = 128,
223                 }
224         },
225
226         .desc = {
227                 .sadb_alg_id = SADB_X_EALG_AESCBC,
228                 .sadb_alg_ivlen = 8,
229                 .sadb_alg_minbits = 128,
230                 .sadb_alg_maxbits = 256
231         }
232 },
233 {
234         .name = "cbc(serpent)",
235         .compat = "serpent",
236
237         .uinfo = {
238                 .encr = {
239                         .blockbits = 128,
240                         .defkeybits = 128,
241                 }
242         },
243
244         .desc = {
245                 .sadb_alg_id = SADB_X_EALG_SERPENTCBC,
246                 .sadb_alg_ivlen = 8,
247                 .sadb_alg_minbits = 128,
248                 .sadb_alg_maxbits = 256,
249         }
250 },
251 {
252         .name = "cbc(twofish)",
253         .compat = "twofish",
254                  
255         .uinfo = {
256                 .encr = {
257                         .blockbits = 128,
258                         .defkeybits = 128,
259                 }
260         },
261
262         .desc = {
263                 .sadb_alg_id = SADB_X_EALG_TWOFISHCBC,
264                 .sadb_alg_ivlen = 8,
265                 .sadb_alg_minbits = 128,
266                 .sadb_alg_maxbits = 256
267         }
268 },
269 };
270
271 static struct xfrm_algo_desc calg_list[] = {
272 {
273         .name = "deflate",
274         .uinfo = {
275                 .comp = {
276                         .threshold = 90,
277                 }
278         },
279         .desc = { .sadb_alg_id = SADB_X_CALG_DEFLATE }
280 },
281 {
282         .name = "lzs",
283         .uinfo = {
284                 .comp = {
285                         .threshold = 90,
286                 }
287         },
288         .desc = { .sadb_alg_id = SADB_X_CALG_LZS }
289 },
290 {
291         .name = "lzjh",
292         .uinfo = {
293                 .comp = {
294                         .threshold = 50,
295                 }
296         },
297         .desc = { .sadb_alg_id = SADB_X_CALG_LZJH }
298 },
299 };
300
301 static inline int aalg_entries(void)
302 {
303         return ARRAY_SIZE(aalg_list);
304 }
305
306 static inline int ealg_entries(void)
307 {
308         return ARRAY_SIZE(ealg_list);
309 }
310
311 static inline int calg_entries(void)
312 {
313         return ARRAY_SIZE(calg_list);
314 }
315
316 /* Todo: generic iterators */
317 struct xfrm_algo_desc *xfrm_aalg_get_byid(int alg_id)
318 {
319         int i;
320
321         for (i = 0; i < aalg_entries(); i++) {
322                 if (aalg_list[i].desc.sadb_alg_id == alg_id) {
323                         if (aalg_list[i].available)
324                                 return &aalg_list[i];
325                         else
326                                 break;
327                 }
328         }
329         return NULL;
330 }
331 EXPORT_SYMBOL_GPL(xfrm_aalg_get_byid);
332
333 struct xfrm_algo_desc *xfrm_ealg_get_byid(int alg_id)
334 {
335         int i;
336
337         for (i = 0; i < ealg_entries(); i++) {
338                 if (ealg_list[i].desc.sadb_alg_id == alg_id) {
339                         if (ealg_list[i].available)
340                                 return &ealg_list[i];
341                         else
342                                 break;
343                 }
344         }
345         return NULL;
346 }
347 EXPORT_SYMBOL_GPL(xfrm_ealg_get_byid);
348
349 struct xfrm_algo_desc *xfrm_calg_get_byid(int alg_id)
350 {
351         int i;
352
353         for (i = 0; i < calg_entries(); i++) {
354                 if (calg_list[i].desc.sadb_alg_id == alg_id) {
355                         if (calg_list[i].available)
356                                 return &calg_list[i];
357                         else
358                                 break;
359                 }
360         }
361         return NULL;
362 }
363 EXPORT_SYMBOL_GPL(xfrm_calg_get_byid);
364
365 static struct xfrm_algo_desc *xfrm_get_byname(struct xfrm_algo_desc *list,
366                                               int entries, u32 type, u32 mask,
367                                               char *name, int probe)
368 {
369         int i, status;
370
371         if (!name)
372                 return NULL;
373
374         for (i = 0; i < entries; i++) {
375                 if (strcmp(name, list[i].name) &&
376                     (!list[i].compat || strcmp(name, list[i].compat)))
377                         continue;
378
379                 if (list[i].available)
380                         return &list[i];
381
382                 if (!probe)
383                         break;
384
385                 status = crypto_has_alg(name, type, mask | CRYPTO_ALG_ASYNC);
386                 if (!status)
387                         break;
388
389                 list[i].available = status;
390                 return &list[i];
391         }
392         return NULL;
393 }
394
395 struct xfrm_algo_desc *xfrm_aalg_get_byname(char *name, int probe)
396 {
397         return xfrm_get_byname(aalg_list, aalg_entries(),
398                                CRYPTO_ALG_TYPE_HASH, CRYPTO_ALG_TYPE_HASH_MASK,
399                                name, probe);
400 }
401 EXPORT_SYMBOL_GPL(xfrm_aalg_get_byname);
402
403 struct xfrm_algo_desc *xfrm_ealg_get_byname(char *name, int probe)
404 {
405         return xfrm_get_byname(ealg_list, ealg_entries(),
406                                CRYPTO_ALG_TYPE_BLKCIPHER, CRYPTO_ALG_TYPE_MASK,
407                                name, probe);
408 }
409 EXPORT_SYMBOL_GPL(xfrm_ealg_get_byname);
410
411 struct xfrm_algo_desc *xfrm_calg_get_byname(char *name, int probe)
412 {
413         return xfrm_get_byname(calg_list, calg_entries(),
414                                CRYPTO_ALG_TYPE_COMPRESS, CRYPTO_ALG_TYPE_MASK,
415                                name, probe);
416 }
417 EXPORT_SYMBOL_GPL(xfrm_calg_get_byname);
418
419 struct xfrm_algo_desc *xfrm_aalg_get_byidx(unsigned int idx)
420 {
421         if (idx >= aalg_entries())
422                 return NULL;
423
424         return &aalg_list[idx];
425 }
426 EXPORT_SYMBOL_GPL(xfrm_aalg_get_byidx);
427
428 struct xfrm_algo_desc *xfrm_ealg_get_byidx(unsigned int idx)
429 {
430         if (idx >= ealg_entries())
431                 return NULL;
432
433         return &ealg_list[idx];
434 }
435 EXPORT_SYMBOL_GPL(xfrm_ealg_get_byidx);
436
437 /*
438  * Probe for the availability of crypto algorithms, and set the available
439  * flag for any algorithms found on the system.  This is typically called by
440  * pfkey during userspace SA add, update or register.
441  */
442 void xfrm_probe_algs(void)
443 {
444 #ifdef CONFIG_CRYPTO
445         int i, status;
446         
447         BUG_ON(in_softirq());
448
449         for (i = 0; i < aalg_entries(); i++) {
450                 status = crypto_has_hash(aalg_list[i].name, 0,
451                                          CRYPTO_ALG_ASYNC);
452                 if (aalg_list[i].available != status)
453                         aalg_list[i].available = status;
454         }
455         
456         for (i = 0; i < ealg_entries(); i++) {
457                 status = crypto_has_blkcipher(ealg_list[i].name, 0,
458                                               CRYPTO_ALG_ASYNC);
459                 if (ealg_list[i].available != status)
460                         ealg_list[i].available = status;
461         }
462         
463         for (i = 0; i < calg_entries(); i++) {
464                 status = crypto_has_comp(calg_list[i].name, 0,
465                                          CRYPTO_ALG_ASYNC);
466                 if (calg_list[i].available != status)
467                         calg_list[i].available = status;
468         }
469 #endif
470 }
471 EXPORT_SYMBOL_GPL(xfrm_probe_algs);
472
473 int xfrm_count_auth_supported(void)
474 {
475         int i, n;
476
477         for (i = 0, n = 0; i < aalg_entries(); i++)
478                 if (aalg_list[i].available)
479                         n++;
480         return n;
481 }
482 EXPORT_SYMBOL_GPL(xfrm_count_auth_supported);
483
484 int xfrm_count_enc_supported(void)
485 {
486         int i, n;
487
488         for (i = 0, n = 0; i < ealg_entries(); i++)
489                 if (ealg_list[i].available)
490                         n++;
491         return n;
492 }
493 EXPORT_SYMBOL_GPL(xfrm_count_enc_supported);
494
495 /* Move to common area: it is shared with AH. */
496
497 int skb_icv_walk(const struct sk_buff *skb, struct hash_desc *desc,
498                  int offset, int len, icv_update_fn_t icv_update)
499 {
500         int start = skb_headlen(skb);
501         int i, copy = start - offset;
502         int err;
503         struct scatterlist sg;
504
505         /* Checksum header. */
506         if (copy > 0) {
507                 if (copy > len)
508                         copy = len;
509                 
510                 sg.page = virt_to_page(skb->data + offset);
511                 sg.offset = (unsigned long)(skb->data + offset) % PAGE_SIZE;
512                 sg.length = copy;
513                 
514                 err = icv_update(desc, &sg, copy);
515                 if (unlikely(err))
516                         return err;
517                 
518                 if ((len -= copy) == 0)
519                         return 0;
520                 offset += copy;
521         }
522
523         for (i = 0; i < skb_shinfo(skb)->nr_frags; i++) {
524                 int end;
525
526                 BUG_TRAP(start <= offset + len);
527
528                 end = start + skb_shinfo(skb)->frags[i].size;
529                 if ((copy = end - offset) > 0) {
530                         skb_frag_t *frag = &skb_shinfo(skb)->frags[i];
531
532                         if (copy > len)
533                                 copy = len;
534                         
535                         sg.page = frag->page;
536                         sg.offset = frag->page_offset + offset-start;
537                         sg.length = copy;
538                         
539                         err = icv_update(desc, &sg, copy);
540                         if (unlikely(err))
541                                 return err;
542
543                         if (!(len -= copy))
544                                 return 0;
545                         offset += copy;
546                 }
547                 start = end;
548         }
549
550         if (skb_shinfo(skb)->frag_list) {
551                 struct sk_buff *list = skb_shinfo(skb)->frag_list;
552
553                 for (; list; list = list->next) {
554                         int end;
555
556                         BUG_TRAP(start <= offset + len);
557
558                         end = start + list->len;
559                         if ((copy = end - offset) > 0) {
560                                 if (copy > len)
561                                         copy = len;
562                                 err = skb_icv_walk(list, desc, offset-start,
563                                                    copy, icv_update);
564                                 if (unlikely(err))
565                                         return err;
566                                 if ((len -= copy) == 0)
567                                         return 0;
568                                 offset += copy;
569                         }
570                         start = end;
571                 }
572         }
573         BUG_ON(len);
574         return 0;
575 }
576 EXPORT_SYMBOL_GPL(skb_icv_walk);
577
578 #if defined(CONFIG_INET_ESP) || defined(CONFIG_INET_ESP_MODULE) || defined(CONFIG_INET6_ESP) || defined(CONFIG_INET6_ESP_MODULE)
579
580 /* Looking generic it is not used in another places. */
581
582 int
583 skb_to_sgvec(struct sk_buff *skb, struct scatterlist *sg, int offset, int len)
584 {
585         int start = skb_headlen(skb);
586         int i, copy = start - offset;
587         int elt = 0;
588
589         if (copy > 0) {
590                 if (copy > len)
591                         copy = len;
592                 sg[elt].page = virt_to_page(skb->data + offset);
593                 sg[elt].offset = (unsigned long)(skb->data + offset) % PAGE_SIZE;
594                 sg[elt].length = copy;
595                 elt++;
596                 if ((len -= copy) == 0)
597                         return elt;
598                 offset += copy;
599         }
600
601         for (i = 0; i < skb_shinfo(skb)->nr_frags; i++) {
602                 int end;
603
604                 BUG_TRAP(start <= offset + len);
605
606                 end = start + skb_shinfo(skb)->frags[i].size;
607                 if ((copy = end - offset) > 0) {
608                         skb_frag_t *frag = &skb_shinfo(skb)->frags[i];
609
610                         if (copy > len)
611                                 copy = len;
612                         sg[elt].page = frag->page;
613                         sg[elt].offset = frag->page_offset+offset-start;
614                         sg[elt].length = copy;
615                         elt++;
616                         if (!(len -= copy))
617                                 return elt;
618                         offset += copy;
619                 }
620                 start = end;
621         }
622
623         if (skb_shinfo(skb)->frag_list) {
624                 struct sk_buff *list = skb_shinfo(skb)->frag_list;
625
626                 for (; list; list = list->next) {
627                         int end;
628
629                         BUG_TRAP(start <= offset + len);
630
631                         end = start + list->len;
632                         if ((copy = end - offset) > 0) {
633                                 if (copy > len)
634                                         copy = len;
635                                 elt += skb_to_sgvec(list, sg+elt, offset - start, copy);
636                                 if ((len -= copy) == 0)
637                                         return elt;
638                                 offset += copy;
639                         }
640                         start = end;
641                 }
642         }
643         BUG_ON(len);
644         return elt;
645 }
646 EXPORT_SYMBOL_GPL(skb_to_sgvec);
647
648 /* Check that skb data bits are writable. If they are not, copy data
649  * to newly created private area. If "tailbits" is given, make sure that
650  * tailbits bytes beyond current end of skb are writable.
651  *
652  * Returns amount of elements of scatterlist to load for subsequent
653  * transformations and pointer to writable trailer skb.
654  */
655
656 int skb_cow_data(struct sk_buff *skb, int tailbits, struct sk_buff **trailer)
657 {
658         int copyflag;
659         int elt;
660         struct sk_buff *skb1, **skb_p;
661
662         /* If skb is cloned or its head is paged, reallocate
663          * head pulling out all the pages (pages are considered not writable
664          * at the moment even if they are anonymous).
665          */
666         if ((skb_cloned(skb) || skb_shinfo(skb)->nr_frags) &&
667             __pskb_pull_tail(skb, skb_pagelen(skb)-skb_headlen(skb)) == NULL)
668                 return -ENOMEM;
669
670         /* Easy case. Most of packets will go this way. */
671         if (!skb_shinfo(skb)->frag_list) {
672                 /* A little of trouble, not enough of space for trailer.
673                  * This should not happen, when stack is tuned to generate
674                  * good frames. OK, on miss we reallocate and reserve even more
675                  * space, 128 bytes is fair. */
676
677                 if (skb_tailroom(skb) < tailbits &&
678                     pskb_expand_head(skb, 0, tailbits-skb_tailroom(skb)+128, GFP_ATOMIC))
679                         return -ENOMEM;
680
681                 /* Voila! */
682                 *trailer = skb;
683                 return 1;
684         }
685
686         /* Misery. We are in troubles, going to mincer fragments... */
687
688         elt = 1;
689         skb_p = &skb_shinfo(skb)->frag_list;
690         copyflag = 0;
691
692         while ((skb1 = *skb_p) != NULL) {
693                 int ntail = 0;
694
695                 /* The fragment is partially pulled by someone,
696                  * this can happen on input. Copy it and everything
697                  * after it. */
698
699                 if (skb_shared(skb1))
700                         copyflag = 1;
701
702                 /* If the skb is the last, worry about trailer. */
703
704                 if (skb1->next == NULL && tailbits) {
705                         if (skb_shinfo(skb1)->nr_frags ||
706                             skb_shinfo(skb1)->frag_list ||
707                             skb_tailroom(skb1) < tailbits)
708                                 ntail = tailbits + 128;
709                 }
710
711                 if (copyflag ||
712                     skb_cloned(skb1) ||
713                     ntail ||
714                     skb_shinfo(skb1)->nr_frags ||
715                     skb_shinfo(skb1)->frag_list) {
716                         struct sk_buff *skb2;
717
718                         /* Fuck, we are miserable poor guys... */
719                         if (ntail == 0)
720                                 skb2 = skb_copy(skb1, GFP_ATOMIC);
721                         else
722                                 skb2 = skb_copy_expand(skb1,
723                                                        skb_headroom(skb1),
724                                                        ntail,
725                                                        GFP_ATOMIC);
726                         if (unlikely(skb2 == NULL))
727                                 return -ENOMEM;
728
729                         if (skb1->sk)
730                                 skb_set_owner_w(skb2, skb1->sk);
731
732                         /* Looking around. Are we still alive?
733                          * OK, link new skb, drop old one */
734
735                         skb2->next = skb1->next;
736                         *skb_p = skb2;
737                         kfree_skb(skb1);
738                         skb1 = skb2;
739                 }
740                 elt++;
741                 *trailer = skb1;
742                 skb_p = &skb1->next;
743         }
744
745         return elt;
746 }
747 EXPORT_SYMBOL_GPL(skb_cow_data);
748
749 void *pskb_put(struct sk_buff *skb, struct sk_buff *tail, int len)
750 {
751         if (tail != skb) {
752                 skb->data_len += len;
753                 skb->len += len;
754         }
755         return skb_put(tail, len);
756 }
757 EXPORT_SYMBOL_GPL(pskb_put);
758 #endif