bf4d623ee1ceb374af73adb3cdb33e658cca7b4d
[linux-2.6.git] / net / rxrpc / ar-key.c
1 /* RxRPC key management
2  *
3  * Copyright (C) 2007 Red Hat, Inc. All Rights Reserved.
4  * Written by David Howells (dhowells@redhat.com)
5  *
6  * This program is free software; you can redistribute it and/or
7  * modify it under the terms of the GNU General Public License
8  * as published by the Free Software Foundation; either version
9  * 2 of the License, or (at your option) any later version.
10  *
11  * RxRPC keys should have a description of describing their purpose:
12  *      "afs@CAMBRIDGE.REDHAT.COM>
13  */
14
15 #include <linux/module.h>
16 #include <linux/net.h>
17 #include <linux/skbuff.h>
18 #include <linux/key-type.h>
19 #include <linux/crypto.h>
20 #include <linux/ctype.h>
21 #include <net/sock.h>
22 #include <net/af_rxrpc.h>
23 #include <keys/rxrpc-type.h>
24 #include <keys/user-type.h>
25 #include "ar-internal.h"
26
27 static int rxrpc_instantiate(struct key *, const void *, size_t);
28 static int rxrpc_instantiate_s(struct key *, const void *, size_t);
29 static void rxrpc_destroy(struct key *);
30 static void rxrpc_destroy_s(struct key *);
31 static void rxrpc_describe(const struct key *, struct seq_file *);
32 static long rxrpc_read(const struct key *, char __user *, size_t);
33
34 /*
35  * rxrpc defined keys take an arbitrary string as the description and an
36  * arbitrary blob of data as the payload
37  */
38 struct key_type key_type_rxrpc = {
39         .name           = "rxrpc",
40         .instantiate    = rxrpc_instantiate,
41         .match          = user_match,
42         .destroy        = rxrpc_destroy,
43         .describe       = rxrpc_describe,
44         .read           = rxrpc_read,
45 };
46 EXPORT_SYMBOL(key_type_rxrpc);
47
48 /*
49  * rxrpc server defined keys take "<serviceId>:<securityIndex>" as the
50  * description and an 8-byte decryption key as the payload
51  */
52 struct key_type key_type_rxrpc_s = {
53         .name           = "rxrpc_s",
54         .instantiate    = rxrpc_instantiate_s,
55         .match          = user_match,
56         .destroy        = rxrpc_destroy_s,
57         .describe       = rxrpc_describe,
58 };
59
60 /*
61  * parse an RxKAD type XDR format token
62  * - the caller guarantees we have at least 4 words
63  */
64 static int rxrpc_instantiate_xdr_rxkad(struct key *key, const __be32 *xdr,
65                                        unsigned toklen)
66 {
67         struct rxrpc_key_token *token;
68         size_t plen;
69         u32 tktlen;
70         int ret;
71
72         _enter(",{%x,%x,%x,%x},%u",
73                ntohl(xdr[0]), ntohl(xdr[1]), ntohl(xdr[2]), ntohl(xdr[3]),
74                toklen);
75
76         if (toklen <= 8 * 4)
77                 return -EKEYREJECTED;
78         tktlen = ntohl(xdr[7]);
79         _debug("tktlen: %x", tktlen);
80         if (tktlen > AFSTOKEN_RK_TIX_MAX)
81                 return -EKEYREJECTED;
82         if (8 * 4 + tktlen != toklen)
83                 return -EKEYREJECTED;
84
85         plen = sizeof(*token) + sizeof(*token->kad) + tktlen;
86         ret = key_payload_reserve(key, key->datalen + plen);
87         if (ret < 0)
88                 return ret;
89
90         plen -= sizeof(*token);
91         token = kmalloc(sizeof(*token), GFP_KERNEL);
92         if (!token)
93                 return -ENOMEM;
94
95         token->kad = kmalloc(plen, GFP_KERNEL);
96         if (!token->kad) {
97                 kfree(token);
98                 return -ENOMEM;
99         }
100
101         token->security_index   = RXRPC_SECURITY_RXKAD;
102         token->kad->ticket_len  = tktlen;
103         token->kad->vice_id     = ntohl(xdr[0]);
104         token->kad->kvno        = ntohl(xdr[1]);
105         token->kad->start       = ntohl(xdr[4]);
106         token->kad->expiry      = ntohl(xdr[5]);
107         token->kad->primary_flag = ntohl(xdr[6]);
108         memcpy(&token->kad->session_key, &xdr[2], 8);
109         memcpy(&token->kad->ticket, &xdr[8], tktlen);
110
111         _debug("SCIX: %u", token->security_index);
112         _debug("TLEN: %u", token->kad->ticket_len);
113         _debug("EXPY: %x", token->kad->expiry);
114         _debug("KVNO: %u", token->kad->kvno);
115         _debug("PRIM: %u", token->kad->primary_flag);
116         _debug("SKEY: %02x%02x%02x%02x%02x%02x%02x%02x",
117                token->kad->session_key[0], token->kad->session_key[1],
118                token->kad->session_key[2], token->kad->session_key[3],
119                token->kad->session_key[4], token->kad->session_key[5],
120                token->kad->session_key[6], token->kad->session_key[7]);
121         if (token->kad->ticket_len >= 8)
122                 _debug("TCKT: %02x%02x%02x%02x%02x%02x%02x%02x",
123                        token->kad->ticket[0], token->kad->ticket[1],
124                        token->kad->ticket[2], token->kad->ticket[3],
125                        token->kad->ticket[4], token->kad->ticket[5],
126                        token->kad->ticket[6], token->kad->ticket[7]);
127
128         /* count the number of tokens attached */
129         key->type_data.x[0]++;
130
131         /* attach the data */
132         token->next = key->payload.data;
133         key->payload.data = token;
134         if (token->kad->expiry < key->expiry)
135                 key->expiry = token->kad->expiry;
136
137         _leave(" = 0");
138         return 0;
139 }
140
141 /*
142  * attempt to parse the data as the XDR format
143  * - the caller guarantees we have more than 7 words
144  */
145 static int rxrpc_instantiate_xdr(struct key *key, const void *data, size_t datalen)
146 {
147         const __be32 *xdr = data, *token;
148         const char *cp;
149         unsigned len, tmp, loop, ntoken, toklen, sec_ix;
150         int ret;
151
152         _enter(",{%x,%x,%x,%x},%zu",
153                ntohl(xdr[0]), ntohl(xdr[1]), ntohl(xdr[2]), ntohl(xdr[3]),
154                datalen);
155
156         if (datalen > AFSTOKEN_LENGTH_MAX)
157                 goto not_xdr;
158
159         /* XDR is an array of __be32's */
160         if (datalen & 3)
161                 goto not_xdr;
162
163         /* the flags should be 0 (the setpag bit must be handled by
164          * userspace) */
165         if (ntohl(*xdr++) != 0)
166                 goto not_xdr;
167         datalen -= 4;
168
169         /* check the cell name */
170         len = ntohl(*xdr++);
171         if (len < 1 || len > AFSTOKEN_CELL_MAX)
172                 goto not_xdr;
173         datalen -= 4;
174         tmp = (len + 3) & ~3;
175         if (tmp > datalen)
176                 goto not_xdr;
177
178         cp = (const char *) xdr;
179         for (loop = 0; loop < len; loop++)
180                 if (!isprint(cp[loop]))
181                         goto not_xdr;
182         if (len < tmp)
183                 for (; loop < tmp; loop++)
184                         if (cp[loop])
185                                 goto not_xdr;
186         _debug("cellname: [%u/%u] '%*.*s'",
187                len, tmp, len, len, (const char *) xdr);
188         datalen -= tmp;
189         xdr += tmp >> 2;
190
191         /* get the token count */
192         if (datalen < 12)
193                 goto not_xdr;
194         ntoken = ntohl(*xdr++);
195         datalen -= 4;
196         _debug("ntoken: %x", ntoken);
197         if (ntoken < 1 || ntoken > AFSTOKEN_MAX)
198                 goto not_xdr;
199
200         /* check each token wrapper */
201         token = xdr;
202         loop = ntoken;
203         do {
204                 if (datalen < 8)
205                         goto not_xdr;
206                 toklen = ntohl(*xdr++);
207                 sec_ix = ntohl(*xdr);
208                 datalen -= 4;
209                 _debug("token: [%x/%zx] %x", toklen, datalen, sec_ix);
210                 if (toklen < 20 || toklen > datalen)
211                         goto not_xdr;
212                 datalen -= (toklen + 3) & ~3;
213                 xdr += (toklen + 3) >> 2;
214
215         } while (--loop > 0);
216
217         _debug("remainder: %zu", datalen);
218         if (datalen != 0)
219                 goto not_xdr;
220
221         /* okay: we're going to assume it's valid XDR format
222          * - we ignore the cellname, relying on the key to be correctly named
223          */
224         do {
225                 xdr = token;
226                 toklen = ntohl(*xdr++);
227                 token = xdr + ((toklen + 3) >> 2);
228                 sec_ix = ntohl(*xdr++);
229                 toklen -= 4;
230
231                 switch (sec_ix) {
232                 case RXRPC_SECURITY_RXKAD:
233                         ret = rxrpc_instantiate_xdr_rxkad(key, xdr, toklen);
234                         if (ret != 0)
235                                 goto error;
236                         break;
237
238                 default:
239                         ret = -EPROTONOSUPPORT;
240                         goto error;
241                 }
242
243         } while (--ntoken > 0);
244
245         _leave(" = 0");
246         return 0;
247
248 not_xdr:
249         _leave(" = -EPROTO");
250         return -EPROTO;
251 error:
252         _leave(" = %d", ret);
253         return ret;
254 }
255
256 /*
257  * instantiate an rxrpc defined key
258  * data should be of the form:
259  *      OFFSET  LEN     CONTENT
260  *      0       4       key interface version number
261  *      4       2       security index (type)
262  *      6       2       ticket length
263  *      8       4       key expiry time (time_t)
264  *      12      4       kvno
265  *      16      8       session key
266  *      24      [len]   ticket
267  *
268  * if no data is provided, then a no-security key is made
269  */
270 static int rxrpc_instantiate(struct key *key, const void *data, size_t datalen)
271 {
272         const struct rxrpc_key_data_v1 *v1;
273         struct rxrpc_key_token *token, **pp;
274         size_t plen;
275         u32 kver;
276         int ret;
277
278         _enter("{%x},,%zu", key_serial(key), datalen);
279
280         /* handle a no-security key */
281         if (!data && datalen == 0)
282                 return 0;
283
284         /* determine if the XDR payload format is being used */
285         if (datalen > 7 * 4) {
286                 ret = rxrpc_instantiate_xdr(key, data, datalen);
287                 if (ret != -EPROTO)
288                         return ret;
289         }
290
291         /* get the key interface version number */
292         ret = -EINVAL;
293         if (datalen <= 4 || !data)
294                 goto error;
295         memcpy(&kver, data, sizeof(kver));
296         data += sizeof(kver);
297         datalen -= sizeof(kver);
298
299         _debug("KEY I/F VERSION: %u", kver);
300
301         ret = -EKEYREJECTED;
302         if (kver != 1)
303                 goto error;
304
305         /* deal with a version 1 key */
306         ret = -EINVAL;
307         if (datalen < sizeof(*v1))
308                 goto error;
309
310         v1 = data;
311         if (datalen != sizeof(*v1) + v1->ticket_length)
312                 goto error;
313
314         _debug("SCIX: %u", v1->security_index);
315         _debug("TLEN: %u", v1->ticket_length);
316         _debug("EXPY: %x", v1->expiry);
317         _debug("KVNO: %u", v1->kvno);
318         _debug("SKEY: %02x%02x%02x%02x%02x%02x%02x%02x",
319                v1->session_key[0], v1->session_key[1],
320                v1->session_key[2], v1->session_key[3],
321                v1->session_key[4], v1->session_key[5],
322                v1->session_key[6], v1->session_key[7]);
323         if (v1->ticket_length >= 8)
324                 _debug("TCKT: %02x%02x%02x%02x%02x%02x%02x%02x",
325                        v1->ticket[0], v1->ticket[1],
326                        v1->ticket[2], v1->ticket[3],
327                        v1->ticket[4], v1->ticket[5],
328                        v1->ticket[6], v1->ticket[7]);
329
330         ret = -EPROTONOSUPPORT;
331         if (v1->security_index != RXRPC_SECURITY_RXKAD)
332                 goto error;
333
334         plen = sizeof(*token->kad) + v1->ticket_length;
335         ret = key_payload_reserve(key, plen + sizeof(*token));
336         if (ret < 0)
337                 goto error;
338
339         ret = -ENOMEM;
340         token = kmalloc(sizeof(*token), GFP_KERNEL);
341         if (!token)
342                 goto error;
343         token->kad = kmalloc(plen, GFP_KERNEL);
344         if (!token->kad)
345                 goto error_free;
346
347         token->security_index           = RXRPC_SECURITY_RXKAD;
348         token->kad->ticket_len          = v1->ticket_length;
349         token->kad->expiry              = v1->expiry;
350         token->kad->kvno                = v1->kvno;
351         memcpy(&token->kad->session_key, &v1->session_key, 8);
352         memcpy(&token->kad->ticket, v1->ticket, v1->ticket_length);
353
354         /* attach the data */
355         key->type_data.x[0]++;
356
357         pp = (struct rxrpc_key_token **)&key->payload.data;
358         while (*pp)
359                 pp = &(*pp)->next;
360         *pp = token;
361         if (token->kad->expiry < key->expiry)
362                 key->expiry = token->kad->expiry;
363         token = NULL;
364         ret = 0;
365
366 error_free:
367         kfree(token);
368 error:
369         return ret;
370 }
371
372 /*
373  * instantiate a server secret key
374  * data should be a pointer to the 8-byte secret key
375  */
376 static int rxrpc_instantiate_s(struct key *key, const void *data,
377                                size_t datalen)
378 {
379         struct crypto_blkcipher *ci;
380
381         _enter("{%x},,%zu", key_serial(key), datalen);
382
383         if (datalen != 8)
384                 return -EINVAL;
385
386         memcpy(&key->type_data, data, 8);
387
388         ci = crypto_alloc_blkcipher("pcbc(des)", 0, CRYPTO_ALG_ASYNC);
389         if (IS_ERR(ci)) {
390                 _leave(" = %ld", PTR_ERR(ci));
391                 return PTR_ERR(ci);
392         }
393
394         if (crypto_blkcipher_setkey(ci, data, 8) < 0)
395                 BUG();
396
397         key->payload.data = ci;
398         _leave(" = 0");
399         return 0;
400 }
401
402 /*
403  * dispose of the data dangling from the corpse of a rxrpc key
404  */
405 static void rxrpc_destroy(struct key *key)
406 {
407         struct rxrpc_key_token *token;
408
409         while ((token = key->payload.data)) {
410                 key->payload.data = token->next;
411                 switch (token->security_index) {
412                 case RXRPC_SECURITY_RXKAD:
413                         kfree(token->kad);
414                         break;
415                 default:
416                         printk(KERN_ERR "Unknown token type %x on rxrpc key\n",
417                                token->security_index);
418                         BUG();
419                 }
420
421                 kfree(token);
422         }
423 }
424
425 /*
426  * dispose of the data dangling from the corpse of a rxrpc key
427  */
428 static void rxrpc_destroy_s(struct key *key)
429 {
430         if (key->payload.data) {
431                 crypto_free_blkcipher(key->payload.data);
432                 key->payload.data = NULL;
433         }
434 }
435
436 /*
437  * describe the rxrpc key
438  */
439 static void rxrpc_describe(const struct key *key, struct seq_file *m)
440 {
441         seq_puts(m, key->description);
442 }
443
444 /*
445  * grab the security key for a socket
446  */
447 int rxrpc_request_key(struct rxrpc_sock *rx, char __user *optval, int optlen)
448 {
449         struct key *key;
450         char *description;
451
452         _enter("");
453
454         if (optlen <= 0 || optlen > PAGE_SIZE - 1)
455                 return -EINVAL;
456
457         description = kmalloc(optlen + 1, GFP_KERNEL);
458         if (!description)
459                 return -ENOMEM;
460
461         if (copy_from_user(description, optval, optlen)) {
462                 kfree(description);
463                 return -EFAULT;
464         }
465         description[optlen] = 0;
466
467         key = request_key(&key_type_rxrpc, description, NULL);
468         if (IS_ERR(key)) {
469                 kfree(description);
470                 _leave(" = %ld", PTR_ERR(key));
471                 return PTR_ERR(key);
472         }
473
474         rx->key = key;
475         kfree(description);
476         _leave(" = 0 [key %x]", key->serial);
477         return 0;
478 }
479
480 /*
481  * grab the security keyring for a server socket
482  */
483 int rxrpc_server_keyring(struct rxrpc_sock *rx, char __user *optval,
484                          int optlen)
485 {
486         struct key *key;
487         char *description;
488
489         _enter("");
490
491         if (optlen <= 0 || optlen > PAGE_SIZE - 1)
492                 return -EINVAL;
493
494         description = kmalloc(optlen + 1, GFP_KERNEL);
495         if (!description)
496                 return -ENOMEM;
497
498         if (copy_from_user(description, optval, optlen)) {
499                 kfree(description);
500                 return -EFAULT;
501         }
502         description[optlen] = 0;
503
504         key = request_key(&key_type_keyring, description, NULL);
505         if (IS_ERR(key)) {
506                 kfree(description);
507                 _leave(" = %ld", PTR_ERR(key));
508                 return PTR_ERR(key);
509         }
510
511         rx->securities = key;
512         kfree(description);
513         _leave(" = 0 [key %x]", key->serial);
514         return 0;
515 }
516
517 /*
518  * generate a server data key
519  */
520 int rxrpc_get_server_data_key(struct rxrpc_connection *conn,
521                               const void *session_key,
522                               time_t expiry,
523                               u32 kvno)
524 {
525         const struct cred *cred = current_cred();
526         struct key *key;
527         int ret;
528
529         struct {
530                 u32 kver;
531                 struct rxrpc_key_data_v1 v1;
532         } data;
533
534         _enter("");
535
536         key = key_alloc(&key_type_rxrpc, "x", 0, 0, cred, 0,
537                         KEY_ALLOC_NOT_IN_QUOTA);
538         if (IS_ERR(key)) {
539                 _leave(" = -ENOMEM [alloc %ld]", PTR_ERR(key));
540                 return -ENOMEM;
541         }
542
543         _debug("key %d", key_serial(key));
544
545         data.kver = 1;
546         data.v1.security_index = RXRPC_SECURITY_RXKAD;
547         data.v1.ticket_length = 0;
548         data.v1.expiry = expiry;
549         data.v1.kvno = 0;
550
551         memcpy(&data.v1.session_key, session_key, sizeof(data.v1.session_key));
552
553         ret = key_instantiate_and_link(key, &data, sizeof(data), NULL, NULL);
554         if (ret < 0)
555                 goto error;
556
557         conn->key = key;
558         _leave(" = 0 [%d]", key_serial(key));
559         return 0;
560
561 error:
562         key_revoke(key);
563         key_put(key);
564         _leave(" = -ENOMEM [ins %d]", ret);
565         return -ENOMEM;
566 }
567 EXPORT_SYMBOL(rxrpc_get_server_data_key);
568
569 /**
570  * rxrpc_get_null_key - Generate a null RxRPC key
571  * @keyname: The name to give the key.
572  *
573  * Generate a null RxRPC key that can be used to indicate anonymous security is
574  * required for a particular domain.
575  */
576 struct key *rxrpc_get_null_key(const char *keyname)
577 {
578         const struct cred *cred = current_cred();
579         struct key *key;
580         int ret;
581
582         key = key_alloc(&key_type_rxrpc, keyname, 0, 0, cred,
583                         KEY_POS_SEARCH, KEY_ALLOC_NOT_IN_QUOTA);
584         if (IS_ERR(key))
585                 return key;
586
587         ret = key_instantiate_and_link(key, NULL, 0, NULL, NULL);
588         if (ret < 0) {
589                 key_revoke(key);
590                 key_put(key);
591                 return ERR_PTR(ret);
592         }
593
594         return key;
595 }
596 EXPORT_SYMBOL(rxrpc_get_null_key);
597
598 /*
599  * read the contents of an rxrpc key
600  * - this returns the result in XDR form
601  */
602 static long rxrpc_read(const struct key *key,
603                        char __user *buffer, size_t buflen)
604 {
605         struct rxrpc_key_token *token;
606         size_t size, toksize;
607         __be32 __user *xdr;
608         u32 cnlen, tktlen, ntoks, zero;
609
610         _enter("");
611
612         /* we don't know what form we should return non-AFS keys in */
613         if (memcmp(key->description, "afs@", 4) != 0)
614                 return -EOPNOTSUPP;
615         cnlen = strlen(key->description + 4);
616
617         /* AFS keys we return in XDR form, so we need to work out the size of
618          * the XDR */
619         size = 2 * 4;   /* flags, cellname len */
620         size += (cnlen + 3) & ~3;       /* cellname */
621         size += 1 * 4;  /* token count */
622
623         ntoks = 0;
624         for (token = key->payload.data; token; token = token->next) {
625                 switch (token->security_index) {
626                 case RXRPC_SECURITY_RXKAD:
627                         size += 2 * 4;  /* length, security index (switch ID) */
628                         size += 8 * 4;  /* viceid, kvno, key*2, begin, end,
629                                          * primary, tktlen */
630                         size += (token->kad->ticket_len + 3) & ~3; /* ticket */
631                         ntoks++;
632                         break;
633
634                 default: /* can't encode */
635                         break;
636                 }
637         }
638
639         if (!buffer || buflen < size)
640                 return size;
641
642         xdr = (__be32 __user *) buffer;
643         zero = 0;
644 #define ENCODE(x)                               \
645         do {                                    \
646                 __be32 y = htonl(x);            \
647                 if (put_user(y, xdr++) < 0)     \
648                         goto fault;             \
649         } while(0)
650
651         ENCODE(0);      /* flags */
652         ENCODE(cnlen);  /* cellname length */
653         if (copy_to_user(xdr, key->description + 4, cnlen) != 0)
654                 goto fault;
655         if (cnlen & 3 &&
656             copy_to_user((u8 *)xdr + cnlen, &zero, 4 - (cnlen & 3)) != 0)
657                 goto fault;
658         xdr += (cnlen + 3) >> 2;
659         ENCODE(ntoks);  /* token count */
660
661         for (token = key->payload.data; token; token = token->next) {
662                 toksize = 1 * 4;        /* sec index */
663
664                 switch (token->security_index) {
665                 case RXRPC_SECURITY_RXKAD:
666                         toksize += 8 * 4;
667                         toksize += (token->kad->ticket_len + 3) & ~3;
668                         ENCODE(toksize);
669                         ENCODE(token->security_index);
670                         ENCODE(token->kad->vice_id);
671                         ENCODE(token->kad->kvno);
672                         if (copy_to_user(xdr, token->kad->session_key, 8) != 0)
673                                 goto fault;
674                         xdr += 8 >> 2;
675                         ENCODE(token->kad->start);
676                         ENCODE(token->kad->expiry);
677                         ENCODE(token->kad->primary_flag);
678                         tktlen = token->kad->ticket_len;
679                         ENCODE(tktlen);
680                         if (copy_to_user(xdr, token->kad->ticket, tktlen) != 0)
681                                 goto fault;
682                         if (tktlen & 3 &&
683                             copy_to_user((u8 *)xdr + tktlen, &zero,
684                                          4 - (tktlen & 3)) != 0)
685                                 goto fault;
686                         xdr += (tktlen + 3) >> 2;
687                         break;
688
689                 default:
690                         break;
691                 }
692         }
693
694 #undef ENCODE
695
696         ASSERTCMP((char __user *) xdr - buffer, ==, size);
697         _leave(" = %zu", size);
698         return size;
699
700 fault:
701         _leave(" = -EFAULT");
702         return -EFAULT;
703 }