1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37#include <linux/types.h>
38#include <linux/crypto.h>
39#include <linux/scatterlist.h>
40#include <net/sctp/sctp.h>
41#include <net/sctp/auth.h>
42
43static struct sctp_hmac sctp_hmac_list[SCTP_AUTH_NUM_HMACS] = {
44 {
45
46 .hmac_id = SCTP_AUTH_HMAC_ID_RESERVED_0,
47 },
48 {
49 .hmac_id = SCTP_AUTH_HMAC_ID_SHA1,
50 .hmac_name="hmac(sha1)",
51 .hmac_len = SCTP_SHA1_SIG_SIZE,
52 },
53 {
54
55 .hmac_id = SCTP_AUTH_HMAC_ID_RESERVED_2,
56 },
57#if defined (CONFIG_CRYPTO_SHA256) || defined (CONFIG_CRYPTO_SHA256_MODULE)
58 {
59 .hmac_id = SCTP_AUTH_HMAC_ID_SHA256,
60 .hmac_name="hmac(sha256)",
61 .hmac_len = SCTP_SHA256_SIG_SIZE,
62 }
63#endif
64};
65
66
67void sctp_auth_key_put(struct sctp_auth_bytes *key)
68{
69 if (!key)
70 return;
71
72 if (atomic_dec_and_test(&key->refcnt)) {
73 kfree(key);
74 SCTP_DBG_OBJCNT_DEC(keys);
75 }
76}
77
78
79static struct sctp_auth_bytes *sctp_auth_create_key(__u32 key_len, gfp_t gfp)
80{
81 struct sctp_auth_bytes *key;
82
83
84 if ((INT_MAX - key_len) < sizeof(struct sctp_auth_bytes))
85 return NULL;
86
87
88 key = kmalloc(sizeof(struct sctp_auth_bytes) + key_len, gfp);
89 if (!key)
90 return NULL;
91
92 key->len = key_len;
93 atomic_set(&key->refcnt, 1);
94 SCTP_DBG_OBJCNT_INC(keys);
95
96 return key;
97}
98
99
100struct sctp_shared_key *sctp_auth_shkey_create(__u16 key_id, gfp_t gfp)
101{
102 struct sctp_shared_key *new;
103
104
105 new = kzalloc(sizeof(struct sctp_shared_key), gfp);
106 if (!new)
107 return NULL;
108
109 INIT_LIST_HEAD(&new->key_list);
110 new->key_id = key_id;
111
112 return new;
113}
114
115
116static void sctp_auth_shkey_free(struct sctp_shared_key *sh_key)
117{
118 BUG_ON(!list_empty(&sh_key->key_list));
119 sctp_auth_key_put(sh_key->key);
120 sh_key->key = NULL;
121 kfree(sh_key);
122}
123
124
125
126
127void sctp_auth_destroy_keys(struct list_head *keys)
128{
129 struct sctp_shared_key *ep_key;
130 struct sctp_shared_key *tmp;
131
132 if (list_empty(keys))
133 return;
134
135 key_for_each_safe(ep_key, tmp, keys) {
136 list_del_init(&ep_key->key_list);
137 sctp_auth_shkey_free(ep_key);
138 }
139}
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157static int sctp_auth_compare_vectors(struct sctp_auth_bytes *vector1,
158 struct sctp_auth_bytes *vector2)
159{
160 int diff;
161 int i;
162 const __u8 *longer;
163
164 diff = vector1->len - vector2->len;
165 if (diff) {
166 longer = (diff > 0) ? vector1->data : vector2->data;
167
168
169
170
171
172 for (i = 0; i < abs(diff); i++ ) {
173 if (longer[i] != 0)
174 return diff;
175 }
176 }
177
178
179 return memcmp(vector1->data, vector2->data, vector1->len);
180}
181
182
183
184
185
186
187
188
189
190
191
192
193static struct sctp_auth_bytes *sctp_auth_make_key_vector(
194 sctp_random_param_t *random,
195 sctp_chunks_param_t *chunks,
196 sctp_hmac_algo_param_t *hmacs,
197 gfp_t gfp)
198{
199 struct sctp_auth_bytes *new;
200 __u32 len;
201 __u32 offset = 0;
202
203 len = ntohs(random->param_hdr.length) + ntohs(hmacs->param_hdr.length);
204 if (chunks)
205 len += ntohs(chunks->param_hdr.length);
206
207 new = kmalloc(sizeof(struct sctp_auth_bytes) + len, gfp);
208 if (!new)
209 return NULL;
210
211 new->len = len;
212
213 memcpy(new->data, random, ntohs(random->param_hdr.length));
214 offset += ntohs(random->param_hdr.length);
215
216 if (chunks) {
217 memcpy(new->data + offset, chunks,
218 ntohs(chunks->param_hdr.length));
219 offset += ntohs(chunks->param_hdr.length);
220 }
221
222 memcpy(new->data + offset, hmacs, ntohs(hmacs->param_hdr.length));
223
224 return new;
225}
226
227
228
229static struct sctp_auth_bytes *sctp_auth_make_local_vector(
230 const struct sctp_association *asoc,
231 gfp_t gfp)
232{
233 return sctp_auth_make_key_vector(
234 (sctp_random_param_t*)asoc->c.auth_random,
235 (sctp_chunks_param_t*)asoc->c.auth_chunks,
236 (sctp_hmac_algo_param_t*)asoc->c.auth_hmacs,
237 gfp);
238}
239
240
241static struct sctp_auth_bytes *sctp_auth_make_peer_vector(
242 const struct sctp_association *asoc,
243 gfp_t gfp)
244{
245 return sctp_auth_make_key_vector(asoc->peer.peer_random,
246 asoc->peer.peer_chunks,
247 asoc->peer.peer_hmacs,
248 gfp);
249}
250
251
252
253
254
255
256
257
258
259
260
261static struct sctp_auth_bytes *sctp_auth_asoc_set_secret(
262 struct sctp_shared_key *ep_key,
263 struct sctp_auth_bytes *first_vector,
264 struct sctp_auth_bytes *last_vector,
265 gfp_t gfp)
266{
267 struct sctp_auth_bytes *secret;
268 __u32 offset = 0;
269 __u32 auth_len;
270
271 auth_len = first_vector->len + last_vector->len;
272 if (ep_key->key)
273 auth_len += ep_key->key->len;
274
275 secret = sctp_auth_create_key(auth_len, gfp);
276 if (!secret)
277 return NULL;
278
279 if (ep_key->key) {
280 memcpy(secret->data, ep_key->key->data, ep_key->key->len);
281 offset += ep_key->key->len;
282 }
283
284 memcpy(secret->data + offset, first_vector->data, first_vector->len);
285 offset += first_vector->len;
286
287 memcpy(secret->data + offset, last_vector->data, last_vector->len);
288
289 return secret;
290}
291
292
293
294
295static struct sctp_auth_bytes *sctp_auth_asoc_create_secret(
296 const struct sctp_association *asoc,
297 struct sctp_shared_key *ep_key,
298 gfp_t gfp)
299{
300 struct sctp_auth_bytes *local_key_vector;
301 struct sctp_auth_bytes *peer_key_vector;
302 struct sctp_auth_bytes *first_vector,
303 *last_vector;
304 struct sctp_auth_bytes *secret = NULL;
305 int cmp;
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320 local_key_vector = sctp_auth_make_local_vector(asoc, gfp);
321 peer_key_vector = sctp_auth_make_peer_vector(asoc, gfp);
322
323 if (!peer_key_vector || !local_key_vector)
324 goto out;
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339 cmp = sctp_auth_compare_vectors(local_key_vector,
340 peer_key_vector);
341 if (cmp < 0) {
342 first_vector = local_key_vector;
343 last_vector = peer_key_vector;
344 } else {
345 first_vector = peer_key_vector;
346 last_vector = local_key_vector;
347 }
348
349 secret = sctp_auth_asoc_set_secret(ep_key, first_vector, last_vector,
350 gfp);
351out:
352 kfree(local_key_vector);
353 kfree(peer_key_vector);
354
355 return secret;
356}
357
358
359
360
361
362int sctp_auth_asoc_copy_shkeys(const struct sctp_endpoint *ep,
363 struct sctp_association *asoc,
364 gfp_t gfp)
365{
366 struct sctp_shared_key *sh_key;
367 struct sctp_shared_key *new;
368
369 BUG_ON(!list_empty(&asoc->endpoint_shared_keys));
370
371 key_for_each(sh_key, &ep->endpoint_shared_keys) {
372 new = sctp_auth_shkey_create(sh_key->key_id, gfp);
373 if (!new)
374 goto nomem;
375
376 new->key = sh_key->key;
377 sctp_auth_key_hold(new->key);
378 list_add(&new->key_list, &asoc->endpoint_shared_keys);
379 }
380
381 return 0;
382
383nomem:
384 sctp_auth_destroy_keys(&asoc->endpoint_shared_keys);
385 return -ENOMEM;
386}
387
388
389
390
391
392int sctp_auth_asoc_init_active_key(struct sctp_association *asoc, gfp_t gfp)
393{
394 struct sctp_auth_bytes *secret;
395 struct sctp_shared_key *ep_key;
396
397
398
399
400 if (!sctp_auth_enable || !asoc->peer.auth_capable)
401 return 0;
402
403
404
405
406
407
408 ep_key = sctp_auth_get_shkey(asoc, asoc->active_key_id);
409 BUG_ON(!ep_key);
410
411 secret = sctp_auth_asoc_create_secret(asoc, ep_key, gfp);
412 if (!secret)
413 return -ENOMEM;
414
415 sctp_auth_key_put(asoc->asoc_shared_key);
416 asoc->asoc_shared_key = secret;
417
418 return 0;
419}
420
421
422
423struct sctp_shared_key *sctp_auth_get_shkey(
424 const struct sctp_association *asoc,
425 __u16 key_id)
426{
427 struct sctp_shared_key *key;
428
429
430 key_for_each(key, &asoc->endpoint_shared_keys) {
431 if (key->key_id == key_id)
432 return key;
433 }
434
435 return NULL;
436}
437
438
439
440
441
442
443
444
445int sctp_auth_init_hmacs(struct sctp_endpoint *ep, gfp_t gfp)
446{
447 struct crypto_hash *tfm = NULL;
448 __u16 id;
449
450
451 if (!sctp_auth_enable) {
452 ep->auth_hmacs = NULL;
453 return 0;
454 }
455
456 if (ep->auth_hmacs)
457 return 0;
458
459
460 ep->auth_hmacs = kzalloc(
461 sizeof(struct crypto_hash *) * SCTP_AUTH_NUM_HMACS,
462 gfp);
463 if (!ep->auth_hmacs)
464 return -ENOMEM;
465
466 for (id = 0; id < SCTP_AUTH_NUM_HMACS; id++) {
467
468
469
470
471
472
473 if (!sctp_hmac_list[id].hmac_name)
474 continue;
475
476
477 if (ep->auth_hmacs[id])
478 continue;
479
480
481 tfm = crypto_alloc_hash(sctp_hmac_list[id].hmac_name, 0,
482 CRYPTO_ALG_ASYNC);
483 if (IS_ERR(tfm))
484 goto out_err;
485
486 ep->auth_hmacs[id] = tfm;
487 }
488
489 return 0;
490
491out_err:
492
493 sctp_auth_destroy_hmacs(ep->auth_hmacs);
494 return -ENOMEM;
495}
496
497
498void sctp_auth_destroy_hmacs(struct crypto_hash *auth_hmacs[])
499{
500 int i;
501
502 if (!auth_hmacs)
503 return;
504
505 for (i = 0; i < SCTP_AUTH_NUM_HMACS; i++)
506 {
507 if (auth_hmacs[i])
508 crypto_free_hash(auth_hmacs[i]);
509 }
510 kfree(auth_hmacs);
511}
512
513
514struct sctp_hmac *sctp_auth_get_hmac(__u16 hmac_id)
515{
516 return &sctp_hmac_list[hmac_id];
517}
518
519
520
521
522struct sctp_hmac *sctp_auth_asoc_get_hmac(const struct sctp_association *asoc)
523{
524 struct sctp_hmac_algo_param *hmacs;
525 __u16 n_elt;
526 __u16 id = 0;
527 int i;
528
529
530 if (asoc->default_hmac_id)
531 return &sctp_hmac_list[asoc->default_hmac_id];
532
533
534
535
536 hmacs = asoc->peer.peer_hmacs;
537 if (!hmacs)
538 return NULL;
539
540 n_elt = (ntohs(hmacs->param_hdr.length) - sizeof(sctp_paramhdr_t)) >> 1;
541 for (i = 0; i < n_elt; i++) {
542 id = ntohs(hmacs->hmac_ids[i]);
543
544
545 if (id > SCTP_AUTH_HMAC_ID_MAX)
546 continue;
547
548
549
550
551
552
553 if (!sctp_hmac_list[id].hmac_name)
554 continue;
555
556 break;
557 }
558
559 if (id == 0)
560 return NULL;
561
562 return &sctp_hmac_list[id];
563}
564
565static int __sctp_auth_find_hmacid(__be16 *hmacs, int n_elts, __be16 hmac_id)
566{
567 int found = 0;
568 int i;
569
570 for (i = 0; i < n_elts; i++) {
571 if (hmac_id == hmacs[i]) {
572 found = 1;
573 break;
574 }
575 }
576
577 return found;
578}
579
580
581int sctp_auth_asoc_verify_hmac_id(const struct sctp_association *asoc,
582 __be16 hmac_id)
583{
584 struct sctp_hmac_algo_param *hmacs;
585 __u16 n_elt;
586
587 if (!asoc)
588 return 0;
589
590 hmacs = (struct sctp_hmac_algo_param *)asoc->c.auth_hmacs;
591 n_elt = (ntohs(hmacs->param_hdr.length) - sizeof(sctp_paramhdr_t)) >> 1;
592
593 return __sctp_auth_find_hmacid(hmacs->hmac_ids, n_elt, hmac_id);
594}
595
596
597
598
599
600
601
602void sctp_auth_asoc_set_default_hmac(struct sctp_association *asoc,
603 struct sctp_hmac_algo_param *hmacs)
604{
605 struct sctp_endpoint *ep;
606 __u16 id;
607 int i;
608 int n_params;
609
610
611 if (asoc->default_hmac_id)
612 return;
613
614 n_params = (ntohs(hmacs->param_hdr.length)
615 - sizeof(sctp_paramhdr_t)) >> 1;
616 ep = asoc->ep;
617 for (i = 0; i < n_params; i++) {
618 id = ntohs(hmacs->hmac_ids[i]);
619
620
621 if (id > SCTP_AUTH_HMAC_ID_MAX)
622 continue;
623
624
625 if (ep->auth_hmacs[id]) {
626 asoc->default_hmac_id = id;
627 break;
628 }
629 }
630}
631
632
633
634static int __sctp_auth_cid(sctp_cid_t chunk, struct sctp_chunks_param *param)
635{
636 unsigned short len;
637 int found = 0;
638 int i;
639
640 if (!param || param->param_hdr.length == 0)
641 return 0;
642
643 len = ntohs(param->param_hdr.length) - sizeof(sctp_paramhdr_t);
644
645
646
647
648
649
650
651 for (i = 0; !found && i < len; i++) {
652 switch (param->chunks[i]) {
653 case SCTP_CID_INIT:
654 case SCTP_CID_INIT_ACK:
655 case SCTP_CID_SHUTDOWN_COMPLETE:
656 case SCTP_CID_AUTH:
657 break;
658
659 default:
660 if (param->chunks[i] == chunk)
661 found = 1;
662 break;
663 }
664 }
665
666 return found;
667}
668
669
670int sctp_auth_send_cid(sctp_cid_t chunk, const struct sctp_association *asoc)
671{
672 if (!sctp_auth_enable || !asoc || !asoc->peer.auth_capable)
673 return 0;
674
675 return __sctp_auth_cid(chunk, asoc->peer.peer_chunks);
676}
677
678
679int sctp_auth_recv_cid(sctp_cid_t chunk, const struct sctp_association *asoc)
680{
681 if (!sctp_auth_enable || !asoc)
682 return 0;
683
684 return __sctp_auth_cid(chunk,
685 (struct sctp_chunks_param *)asoc->c.auth_chunks);
686}
687
688
689
690
691
692
693
694
695
696
697void sctp_auth_calculate_hmac(const struct sctp_association *asoc,
698 struct sk_buff *skb,
699 struct sctp_auth_chunk *auth,
700 gfp_t gfp)
701{
702 struct scatterlist sg;
703 struct hash_desc desc;
704 struct sctp_auth_bytes *asoc_key;
705 __u16 key_id, hmac_id;
706 __u8 *digest;
707 unsigned char *end;
708 int free_key = 0;
709
710
711
712
713
714 key_id = ntohs(auth->auth_hdr.shkey_id);
715 hmac_id = ntohs(auth->auth_hdr.hmac_id);
716
717 if (key_id == asoc->active_key_id)
718 asoc_key = asoc->asoc_shared_key;
719 else {
720 struct sctp_shared_key *ep_key;
721
722 ep_key = sctp_auth_get_shkey(asoc, key_id);
723 if (!ep_key)
724 return;
725
726 asoc_key = sctp_auth_asoc_create_secret(asoc, ep_key, gfp);
727 if (!asoc_key)
728 return;
729
730 free_key = 1;
731 }
732
733
734 end = skb_tail_pointer(skb);
735 sg_init_one(&sg, auth, end - (unsigned char *)auth);
736
737 desc.tfm = asoc->ep->auth_hmacs[hmac_id];
738 desc.flags = 0;
739
740 digest = auth->auth_hdr.hmac;
741 if (crypto_hash_setkey(desc.tfm, &asoc_key->data[0], asoc_key->len))
742 goto free;
743
744 crypto_hash_digest(&desc, &sg, sg.length, digest);
745
746free:
747 if (free_key)
748 sctp_auth_key_put(asoc_key);
749}
750
751
752
753
754int sctp_auth_ep_add_chunkid(struct sctp_endpoint *ep, __u8 chunk_id)
755{
756 struct sctp_chunks_param *p = ep->auth_chunk_list;
757 __u16 nchunks;
758 __u16 param_len;
759
760
761 if (__sctp_auth_cid(chunk_id, p))
762 return 0;
763
764
765 param_len = ntohs(p->param_hdr.length);
766 nchunks = param_len - sizeof(sctp_paramhdr_t);
767 if (nchunks == SCTP_NUM_CHUNK_TYPES)
768 return -EINVAL;
769
770 p->chunks[nchunks] = chunk_id;
771 p->param_hdr.length = htons(param_len + 1);
772 return 0;
773}
774
775
776int sctp_auth_ep_set_hmacs(struct sctp_endpoint *ep,
777 struct sctp_hmacalgo *hmacs)
778{
779 int has_sha1 = 0;
780 __u16 id;
781 int i;
782
783
784
785
786 for (i = 0; i < hmacs->shmac_num_idents; i++) {
787 id = hmacs->shmac_idents[i];
788
789 if (id > SCTP_AUTH_HMAC_ID_MAX)
790 return -EOPNOTSUPP;
791
792 if (SCTP_AUTH_HMAC_ID_SHA1 == id)
793 has_sha1 = 1;
794
795 if (!sctp_hmac_list[id].hmac_name)
796 return -EOPNOTSUPP;
797 }
798
799 if (!has_sha1)
800 return -EINVAL;
801
802 memcpy(ep->auth_hmacs_list->hmac_ids, &hmacs->shmac_idents[0],
803 hmacs->shmac_num_idents * sizeof(__u16));
804 ep->auth_hmacs_list->param_hdr.length = htons(sizeof(sctp_paramhdr_t) +
805 hmacs->shmac_num_idents * sizeof(__u16));
806 return 0;
807}
808
809
810
811
812
813int sctp_auth_set_key(struct sctp_endpoint *ep,
814 struct sctp_association *asoc,
815 struct sctp_authkey *auth_key)
816{
817 struct sctp_shared_key *cur_key = NULL;
818 struct sctp_auth_bytes *key;
819 struct list_head *sh_keys;
820 int replace = 0;
821
822
823
824
825 if (asoc)
826 sh_keys = &asoc->endpoint_shared_keys;
827 else
828 sh_keys = &ep->endpoint_shared_keys;
829
830 key_for_each(cur_key, sh_keys) {
831 if (cur_key->key_id == auth_key->sca_keynumber) {
832 replace = 1;
833 break;
834 }
835 }
836
837
838
839
840 if (!replace) {
841 cur_key = sctp_auth_shkey_create(auth_key->sca_keynumber,
842 GFP_KERNEL);
843 if (!cur_key)
844 return -ENOMEM;
845 }
846
847
848 key = sctp_auth_create_key(auth_key->sca_keylength, GFP_KERNEL);
849 if (!key)
850 goto nomem;
851
852 memcpy(key->data, &auth_key->sca_key[0], auth_key->sca_keylength);
853
854
855
856
857
858 if (replace)
859 sctp_auth_key_put(cur_key->key);
860 else
861 list_add(&cur_key->key_list, sh_keys);
862
863 cur_key->key = key;
864 sctp_auth_key_hold(key);
865
866 return 0;
867nomem:
868 if (!replace)
869 sctp_auth_shkey_free(cur_key);
870
871 return -ENOMEM;
872}
873
874int sctp_auth_set_active_key(struct sctp_endpoint *ep,
875 struct sctp_association *asoc,
876 __u16 key_id)
877{
878 struct sctp_shared_key *key;
879 struct list_head *sh_keys;
880 int found = 0;
881
882
883 if (asoc)
884 sh_keys = &asoc->endpoint_shared_keys;
885 else
886 sh_keys = &ep->endpoint_shared_keys;
887
888 key_for_each(key, sh_keys) {
889 if (key->key_id == key_id) {
890 found = 1;
891 break;
892 }
893 }
894
895 if (!found)
896 return -EINVAL;
897
898 if (asoc) {
899 asoc->active_key_id = key_id;
900 sctp_auth_asoc_init_active_key(asoc, GFP_KERNEL);
901 } else
902 ep->active_key_id = key_id;
903
904 return 0;
905}
906
907int sctp_auth_del_key_id(struct sctp_endpoint *ep,
908 struct sctp_association *asoc,
909 __u16 key_id)
910{
911 struct sctp_shared_key *key;
912 struct list_head *sh_keys;
913 int found = 0;
914
915
916
917
918 if (asoc) {
919 if (asoc->active_key_id == key_id)
920 return -EINVAL;
921
922 sh_keys = &asoc->endpoint_shared_keys;
923 } else {
924 if (ep->active_key_id == key_id)
925 return -EINVAL;
926
927 sh_keys = &ep->endpoint_shared_keys;
928 }
929
930 key_for_each(key, sh_keys) {
931 if (key->key_id == key_id) {
932 found = 1;
933 break;
934 }
935 }
936
937 if (!found)
938 return -EINVAL;
939
940
941 list_del_init(&key->key_list);
942 sctp_auth_shkey_free(key);
943
944 return 0;
945}
946