blob: 56935bbc1496f535e646d2e8ef03c9bddb3a2634 [file] [log] [blame]
Vlad Yasevich60c778b2008-01-11 09:57:09 -05001/* SCTP kernel implementation
Vlad Yasevich1f485642007-10-09 01:15:59 -07002 * (C) Copyright 2007 Hewlett-Packard Development Company, L.P.
3 *
Vlad Yasevich60c778b2008-01-11 09:57:09 -05004 * This file is part of the SCTP kernel implementation
Vlad Yasevich1f485642007-10-09 01:15:59 -07005 *
Vlad Yasevich60c778b2008-01-11 09:57:09 -05006 * This SCTP implementation is free software;
Vlad Yasevich1f485642007-10-09 01:15:59 -07007 * you can redistribute it and/or modify it under the terms of
8 * the GNU General Public License as published by
9 * the Free Software Foundation; either version 2, or (at your option)
10 * any later version.
11 *
Vlad Yasevich60c778b2008-01-11 09:57:09 -050012 * This SCTP implementation is distributed in the hope that it
Vlad Yasevich1f485642007-10-09 01:15:59 -070013 * will be useful, but WITHOUT ANY WARRANTY; without even the implied
14 * ************************
15 * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
16 * See the GNU General Public License for more details.
17 *
18 * You should have received a copy of the GNU General Public License
19 * along with GNU CC; see the file COPYING. If not, write to
20 * the Free Software Foundation, 59 Temple Place - Suite 330,
21 * Boston, MA 02111-1307, USA.
22 *
23 * Please send any bug reports or fixes you make to the
24 * email address(es):
25 * lksctp developers <lksctp-developers@lists.sourceforge.net>
26 *
27 * Or submit a bug report through the following website:
28 * http://www.sf.net/projects/lksctp
29 *
30 * Written or modified by:
31 * Vlad Yasevich <vladislav.yasevich@hp.com>
32 *
33 * Any bugs reported given to us we will try to fix... any fixes shared will
34 * be incorporated into the next SCTP release.
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 /* id 0 is reserved. as all 0 */
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 /* id 2 is reserved as well */
55 .hmac_id = SCTP_AUTH_HMAC_ID_RESERVED_2,
56 },
Vlad Yasevichb7e0fe92007-11-29 09:53:52 -050057#if defined (CONFIG_CRYPTO_SHA256) || defined (CONFIG_CRYPTO_SHA256_MODULE)
Vlad Yasevich1f485642007-10-09 01:15:59 -070058 {
59 .hmac_id = SCTP_AUTH_HMAC_ID_SHA256,
60 .hmac_name="hmac(sha256)",
61 .hmac_len = SCTP_SHA256_SIG_SIZE,
62 }
Vlad Yasevichb7e0fe92007-11-29 09:53:52 -050063#endif
Vlad Yasevich1f485642007-10-09 01:15:59 -070064};
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/* Create a new key structure of a given length */
79static struct sctp_auth_bytes *sctp_auth_create_key(__u32 key_len, gfp_t gfp)
80{
81 struct sctp_auth_bytes *key;
82
Vlad Yasevich30c22352008-08-25 15:16:19 -070083 /* Verify that we are not going to overflow INT_MAX */
84 if ((INT_MAX - key_len) < sizeof(struct sctp_auth_bytes))
85 return NULL;
86
Vlad Yasevich1f485642007-10-09 01:15:59 -070087 /* Allocate the shared key */
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/* Create a new shared key container with a give key id */
100struct sctp_shared_key *sctp_auth_shkey_create(__u16 key_id, gfp_t gfp)
101{
102 struct sctp_shared_key *new;
103
104 /* Allocate the shared key container */
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/* Free the shared key stucture */
Adrian Bunk8ad7c62b2007-10-26 04:21:23 -0700116static void sctp_auth_shkey_free(struct sctp_shared_key *sh_key)
Vlad Yasevich1f485642007-10-09 01:15:59 -0700117{
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/* Destory the entire key list. This is done during the
125 * associon and endpoint free process.
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/* Compare two byte vectors as numbers. Return values
142 * are:
143 * 0 - vectors are equal
Frederik Schwarzer025dfda2008-10-16 19:02:37 +0200144 * < 0 - vector 1 is smaller than vector2
145 * > 0 - vector 1 is greater than vector2
Vlad Yasevich1f485642007-10-09 01:15:59 -0700146 *
147 * Algorithm is:
148 * This is performed by selecting the numerically smaller key vector...
149 * If the key vectors are equal as numbers but differ in length ...
150 * the shorter vector is considered smaller
151 *
152 * Examples (with small values):
153 * 000123456789 > 123456789 (first number is longer)
154 * 000123456789 < 234567891 (second number is larger numerically)
155 * 123456789 > 2345678 (first number is both larger & longer)
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 /* Check to see if the longer number is
169 * lead-zero padded. If it is not, it
170 * is automatically larger numerically.
171 */
172 for (i = 0; i < abs(diff); i++ ) {
173 if (longer[i] != 0)
174 return diff;
175 }
176 }
177
178 /* lengths are the same, compare numbers */
179 return memcmp(vector1->data, vector2->data, vector1->len);
180}
181
182/*
183 * Create a key vector as described in SCTP-AUTH, Section 6.1
184 * The RANDOM parameter, the CHUNKS parameter and the HMAC-ALGO
185 * parameter sent by each endpoint are concatenated as byte vectors.
186 * These parameters include the parameter type, parameter length, and
187 * the parameter value, but padding is omitted; all padding MUST be
188 * removed from this concatenation before proceeding with further
189 * computation of keys. Parameters which were not sent are simply
190 * omitted from the concatenation process. The resulting two vectors
191 * are called the two key vectors.
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/* Make a key vector based on our local parameters */
Adrian Bunk8ad7c62b2007-10-26 04:21:23 -0700229static struct sctp_auth_bytes *sctp_auth_make_local_vector(
Vlad Yasevich1f485642007-10-09 01:15:59 -0700230 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/* Make a key vector based on peer's parameters */
Adrian Bunk8ad7c62b2007-10-26 04:21:23 -0700241static struct sctp_auth_bytes *sctp_auth_make_peer_vector(
Vlad Yasevich1f485642007-10-09 01:15:59 -0700242 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/* Set the value of the association shared key base on the parameters
253 * given. The algorithm is:
254 * From the endpoint pair shared keys and the key vectors the
255 * association shared keys are computed. This is performed by selecting
256 * the numerically smaller key vector and concatenating it to the
257 * endpoint pair shared key, and then concatenating the numerically
258 * larger key vector to that. The result of the concatenation is the
259 * association shared key.
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/* Create an association shared key. Follow the algorithm
293 * described in SCTP-AUTH, Section 6.1
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 /* Now we need to build the key vectors
309 * SCTP-AUTH , Section 6.1
310 * The RANDOM parameter, the CHUNKS parameter and the HMAC-ALGO
311 * parameter sent by each endpoint are concatenated as byte vectors.
312 * These parameters include the parameter type, parameter length, and
313 * the parameter value, but padding is omitted; all padding MUST be
314 * removed from this concatenation before proceeding with further
315 * computation of keys. Parameters which were not sent are simply
316 * omitted from the concatenation process. The resulting two vectors
317 * are called the two key vectors.
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 /* Figure out the order in wich the key_vectors will be
327 * added to the endpoint shared key.
328 * SCTP-AUTH, Section 6.1:
329 * This is performed by selecting the numerically smaller key
330 * vector and concatenating it to the endpoint pair shared
331 * key, and then concatenating the numerically larger key
332 * vector to that. If the key vectors are equal as numbers
333 * but differ in length, then the concatenation order is the
334 * endpoint shared key, followed by the shorter key vector,
335 * followed by the longer key vector. Otherwise, the key
336 * vectors are identical, and may be concatenated to the
337 * endpoint pair key in any order.
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 * Populate the association overlay list with the list
360 * from the endpoint.
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/* Public interface to creat the association shared key.
390 * See code above for the algorithm.
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 /* If we don't support AUTH, or peer is not capable
398 * we don't need to do anything.
399 */
400 if (!sctp_auth_enable || !asoc->peer.auth_capable)
401 return 0;
402
403 /* If the key_id is non-zero and we couldn't find an
404 * endpoint pair shared key, we can't compute the
405 * secret.
406 * For key_id 0, endpoint pair shared key is a NULL key.
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/* Find the endpoint pair shared key based on the key_id */
423struct sctp_shared_key *sctp_auth_get_shkey(
424 const struct sctp_association *asoc,
425 __u16 key_id)
426{
Wei Yongjun7cc08b52008-02-05 03:03:06 -0800427 struct sctp_shared_key *key;
Vlad Yasevich1f485642007-10-09 01:15:59 -0700428
429 /* First search associations set of endpoint pair shared keys */
430 key_for_each(key, &asoc->endpoint_shared_keys) {
431 if (key->key_id == key_id)
Wei Yongjun7cc08b52008-02-05 03:03:06 -0800432 return key;
Vlad Yasevich1f485642007-10-09 01:15:59 -0700433 }
434
Wei Yongjun7cc08b52008-02-05 03:03:06 -0800435 return NULL;
Vlad Yasevich1f485642007-10-09 01:15:59 -0700436}
437
438/*
439 * Initialize all the possible digest transforms that we can use. Right now
440 * now, the supported digests are SHA1 and SHA256. We do this here once
441 * because of the restrictiong that transforms may only be allocated in
442 * user context. This forces us to pre-allocated all possible transforms
443 * at the endpoint init time.
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 /* if the transforms are already allocted, we are done */
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 /* Allocated the array of pointers to transorms */
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 /* See is we support the id. Supported IDs have name and
469 * length fields set, so that we can allocated and use
470 * them. We can safely just check for name, for without the
471 * name, we can't allocate the TFM.
472 */
473 if (!sctp_hmac_list[id].hmac_name)
474 continue;
475
476 /* If this TFM has been allocated, we are all set */
477 if (ep->auth_hmacs[id])
478 continue;
479
480 /* Allocate the ID */
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:
Coly Li73ac36e2009-01-07 18:09:16 -0800492 /* Clean up any successful allocations */
Vlad Yasevich1f485642007-10-09 01:15:59 -0700493 sctp_auth_destroy_hmacs(ep->auth_hmacs);
494 return -ENOMEM;
495}
496
497/* Destroy the hmac tfm array */
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/* Get an hmac description information that we can use to build
520 * the AUTH chunk
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 /* If we have a default entry, use it */
530 if (asoc->default_hmac_id)
531 return &sctp_hmac_list[asoc->default_hmac_id];
532
533 /* Since we do not have a default entry, find the first entry
534 * we support and return that. Do not cache that id.
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 /* Check the id is in the supported range */
545 if (id > SCTP_AUTH_HMAC_ID_MAX)
546 continue;
547
548 /* See is we support the id. Supported IDs have name and
549 * length fields set, so that we can allocated and use
550 * them. We can safely just check for name, for without the
551 * name, we can't allocate the TFM.
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
Al Virod06f6082007-10-29 05:03:23 +0000565static int __sctp_auth_find_hmacid(__be16 *hmacs, int n_elts, __be16 hmac_id)
Vlad Yasevich1f485642007-10-09 01:15:59 -0700566{
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/* See if the HMAC_ID is one that we claim as supported */
581int sctp_auth_asoc_verify_hmac_id(const struct sctp_association *asoc,
Al Virod06f6082007-10-29 05:03:23 +0000582 __be16 hmac_id)
Vlad Yasevich1f485642007-10-09 01:15:59 -0700583{
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/* Cache the default HMAC id. This to follow this text from SCTP-AUTH:
598 * Section 6.1:
599 * The receiver of a HMAC-ALGO parameter SHOULD use the first listed
600 * algorithm it supports.
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 /* if the default id is already set, use it */
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 /* Check the id is in the supported range */
621 if (id > SCTP_AUTH_HMAC_ID_MAX)
622 continue;
623
624 /* If this TFM has been allocated, use this id */
625 if (ep->auth_hmacs[id]) {
626 asoc->default_hmac_id = id;
627 break;
628 }
629 }
630}
631
632
633/* Check to see if the given chunk is supposed to be authenticated */
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
Vlad Yasevich555d3d52007-11-29 08:56:16 -0500640 if (!param || param->param_hdr.length == 0)
Vlad Yasevich1f485642007-10-09 01:15:59 -0700641 return 0;
642
643 len = ntohs(param->param_hdr.length) - sizeof(sctp_paramhdr_t);
644
645 /* SCTP-AUTH, Section 3.2
646 * The chunk types for INIT, INIT-ACK, SHUTDOWN-COMPLETE and AUTH
647 * chunks MUST NOT be listed in the CHUNKS parameter. However, if
648 * a CHUNKS parameter is received then the types for INIT, INIT-ACK,
649 * SHUTDOWN-COMPLETE and AUTH chunks MUST be ignored.
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/* Check if peer requested that this chunk is authenticated */
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/* Check if we requested that peer authenticate this chunk. */
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/* SCTP-AUTH: Section 6.2:
689 * The sender MUST calculate the MAC as described in RFC2104 [2] using
690 * the hash function H as described by the MAC Identifier and the shared
691 * association key K based on the endpoint pair shared key described by
692 * the shared key identifier. The 'data' used for the computation of
693 * the AUTH-chunk is given by the AUTH chunk with its HMAC field set to
694 * zero (as shown in Figure 6) followed by all chunks that are placed
695 * after the AUTH chunk in the SCTP packet.
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 /* Extract the info we need:
711 * - hmac id
712 * - key id
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 /* set up scatter list */
734 end = skb_tail_pointer(skb);
Herbert Xu68e3f5d2007-10-27 00:52:07 -0700735 sg_init_one(&sg, auth, end - (unsigned char *)auth);
Vlad Yasevich1f485642007-10-09 01:15:59 -0700736
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}
Vlad Yasevich65b07e52007-09-16 19:34:00 -0700750
751/* API Helpers */
752
753/* Add a chunk to the endpoint authenticated chunk list */
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 /* If this chunk is already specified, we are done */
761 if (__sctp_auth_cid(chunk_id, p))
762 return 0;
763
764 /* Check if we can add this chunk to the array */
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/* Add hmac identifires to the endpoint list of supported hmac ids */
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 /* Scan the list looking for unsupported id. Also make sure that
784 * SHA1 is specified.
785 */
786 for (i = 0; i < hmacs->shmac_num_idents; i++) {
787 id = hmacs->shmac_idents[i];
788
Vlad Yasevichd9724052008-08-27 16:09:49 -0700789 if (id > SCTP_AUTH_HMAC_ID_MAX)
790 return -EOPNOTSUPP;
791
Vlad Yasevich65b07e52007-09-16 19:34:00 -0700792 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/* Set a new shared key on either endpoint or association. If the
810 * the key with a same ID already exists, replace the key (remove the
811 * old key and add a new one).
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 /* Try to find the given key id to see if
823 * we are doing a replace, or adding a new key
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 /* If we are not replacing a key id, we need to allocate
838 * a shared key.
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 /* Create a new key data based on the info passed in */
Vlad Yasevich7e8616d2008-02-27 16:04:52 -0500848 key = sctp_auth_create_key(auth_key->sca_keylength, GFP_KERNEL);
Vlad Yasevich65b07e52007-09-16 19:34:00 -0700849 if (!key)
850 goto nomem;
851
Vlad Yasevich7e8616d2008-02-27 16:04:52 -0500852 memcpy(key->data, &auth_key->sca_key[0], auth_key->sca_keylength);
Vlad Yasevich65b07e52007-09-16 19:34:00 -0700853
854 /* If we are replacing, remove the old keys data from the
855 * key id. If we are adding new key id, add it to the
856 * list.
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 /* The key identifier MUST correst to an existing key */
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 /* The key identifier MUST NOT be the current active key
916 * The key identifier MUST correst to an existing key
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 /* Delete the shared key */
941 list_del_init(&key->key_list);
942 sctp_auth_shkey_free(key);
943
944 return 0;
945}