Loading...
1// SPDX-License-Identifier: GPL-2.0-or-later
2/* RxRPC key management
3 *
4 * Copyright (C) 2007 Red Hat, Inc. All Rights Reserved.
5 * Written by David Howells (dhowells@redhat.com)
6 *
7 * RxRPC keys should have a description of describing their purpose:
8 * "afs@example.com"
9 */
10
11#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
12
13#include <crypto/skcipher.h>
14#include <linux/module.h>
15#include <linux/net.h>
16#include <linux/skbuff.h>
17#include <linux/key-type.h>
18#include <linux/ctype.h>
19#include <linux/slab.h>
20#include <net/sock.h>
21#include <net/af_rxrpc.h>
22#include <keys/rxrpc-type.h>
23#include <keys/user-type.h>
24#include "ar-internal.h"
25
26static int rxrpc_preparse(struct key_preparsed_payload *);
27static void rxrpc_free_preparse(struct key_preparsed_payload *);
28static void rxrpc_destroy(struct key *);
29static void rxrpc_describe(const struct key *, struct seq_file *);
30static long rxrpc_read(const struct key *, char *, size_t);
31
32/*
33 * rxrpc defined keys take an arbitrary string as the description and an
34 * arbitrary blob of data as the payload
35 */
36struct key_type key_type_rxrpc = {
37 .name = "rxrpc",
38 .flags = KEY_TYPE_NET_DOMAIN,
39 .preparse = rxrpc_preparse,
40 .free_preparse = rxrpc_free_preparse,
41 .instantiate = generic_key_instantiate,
42 .destroy = rxrpc_destroy,
43 .describe = rxrpc_describe,
44 .read = rxrpc_read,
45};
46EXPORT_SYMBOL(key_type_rxrpc);
47
48/*
49 * parse an RxKAD type XDR format token
50 * - the caller guarantees we have at least 4 words
51 */
52static int rxrpc_preparse_xdr_rxkad(struct key_preparsed_payload *prep,
53 size_t datalen,
54 const __be32 *xdr, unsigned int toklen)
55{
56 struct rxrpc_key_token *token, **pptoken;
57 time64_t expiry;
58 size_t plen;
59 u32 tktlen;
60
61 _enter(",{%x,%x,%x,%x},%u",
62 ntohl(xdr[0]), ntohl(xdr[1]), ntohl(xdr[2]), ntohl(xdr[3]),
63 toklen);
64
65 if (toklen <= 8 * 4)
66 return -EKEYREJECTED;
67 tktlen = ntohl(xdr[7]);
68 _debug("tktlen: %x", tktlen);
69 if (tktlen > AFSTOKEN_RK_TIX_MAX)
70 return -EKEYREJECTED;
71 if (toklen < 8 * 4 + tktlen)
72 return -EKEYREJECTED;
73
74 plen = sizeof(*token) + sizeof(*token->kad) + tktlen;
75 prep->quotalen = datalen + plen;
76
77 plen -= sizeof(*token);
78 token = kzalloc(sizeof(*token), GFP_KERNEL);
79 if (!token)
80 return -ENOMEM;
81
82 token->kad = kzalloc(plen, GFP_KERNEL);
83 if (!token->kad) {
84 kfree(token);
85 return -ENOMEM;
86 }
87
88 token->security_index = RXRPC_SECURITY_RXKAD;
89 token->kad->ticket_len = tktlen;
90 token->kad->vice_id = ntohl(xdr[0]);
91 token->kad->kvno = ntohl(xdr[1]);
92 token->kad->start = ntohl(xdr[4]);
93 token->kad->expiry = ntohl(xdr[5]);
94 token->kad->primary_flag = ntohl(xdr[6]);
95 memcpy(&token->kad->session_key, &xdr[2], 8);
96 memcpy(&token->kad->ticket, &xdr[8], tktlen);
97
98 _debug("SCIX: %u", token->security_index);
99 _debug("TLEN: %u", token->kad->ticket_len);
100 _debug("EXPY: %x", token->kad->expiry);
101 _debug("KVNO: %u", token->kad->kvno);
102 _debug("PRIM: %u", token->kad->primary_flag);
103 _debug("SKEY: %02x%02x%02x%02x%02x%02x%02x%02x",
104 token->kad->session_key[0], token->kad->session_key[1],
105 token->kad->session_key[2], token->kad->session_key[3],
106 token->kad->session_key[4], token->kad->session_key[5],
107 token->kad->session_key[6], token->kad->session_key[7]);
108 if (token->kad->ticket_len >= 8)
109 _debug("TCKT: %02x%02x%02x%02x%02x%02x%02x%02x",
110 token->kad->ticket[0], token->kad->ticket[1],
111 token->kad->ticket[2], token->kad->ticket[3],
112 token->kad->ticket[4], token->kad->ticket[5],
113 token->kad->ticket[6], token->kad->ticket[7]);
114
115 /* count the number of tokens attached */
116 prep->payload.data[1] = (void *)((unsigned long)prep->payload.data[1] + 1);
117
118 /* attach the data */
119 for (pptoken = (struct rxrpc_key_token **)&prep->payload.data[0];
120 *pptoken;
121 pptoken = &(*pptoken)->next)
122 continue;
123 *pptoken = token;
124 expiry = rxrpc_u32_to_time64(token->kad->expiry);
125 if (expiry < prep->expiry)
126 prep->expiry = expiry;
127
128 _leave(" = 0");
129 return 0;
130}
131
132/*
133 * attempt to parse the data as the XDR format
134 * - the caller guarantees we have more than 7 words
135 */
136static int rxrpc_preparse_xdr(struct key_preparsed_payload *prep)
137{
138 const __be32 *xdr = prep->data, *token, *p;
139 const char *cp;
140 unsigned int len, paddedlen, loop, ntoken, toklen, sec_ix;
141 size_t datalen = prep->datalen;
142 int ret, ret2;
143
144 _enter(",{%x,%x,%x,%x},%zu",
145 ntohl(xdr[0]), ntohl(xdr[1]), ntohl(xdr[2]), ntohl(xdr[3]),
146 prep->datalen);
147
148 if (datalen > AFSTOKEN_LENGTH_MAX)
149 goto not_xdr;
150
151 /* XDR is an array of __be32's */
152 if (datalen & 3)
153 goto not_xdr;
154
155 /* the flags should be 0 (the setpag bit must be handled by
156 * userspace) */
157 if (ntohl(*xdr++) != 0)
158 goto not_xdr;
159 datalen -= 4;
160
161 /* check the cell name */
162 len = ntohl(*xdr++);
163 if (len < 1 || len > AFSTOKEN_CELL_MAX)
164 goto not_xdr;
165 datalen -= 4;
166 paddedlen = (len + 3) & ~3;
167 if (paddedlen > datalen)
168 goto not_xdr;
169
170 cp = (const char *) xdr;
171 for (loop = 0; loop < len; loop++)
172 if (!isprint(cp[loop]))
173 goto not_xdr;
174 for (; loop < paddedlen; loop++)
175 if (cp[loop])
176 goto not_xdr;
177 _debug("cellname: [%u/%u] '%*.*s'",
178 len, paddedlen, len, len, (const char *) xdr);
179 datalen -= paddedlen;
180 xdr += paddedlen >> 2;
181
182 /* get the token count */
183 if (datalen < 12)
184 goto not_xdr;
185 ntoken = ntohl(*xdr++);
186 datalen -= 4;
187 _debug("ntoken: %x", ntoken);
188 if (ntoken < 1 || ntoken > AFSTOKEN_MAX)
189 goto not_xdr;
190
191 /* check each token wrapper */
192 p = xdr;
193 loop = ntoken;
194 do {
195 if (datalen < 8)
196 goto not_xdr;
197 toklen = ntohl(*p++);
198 sec_ix = ntohl(*p);
199 datalen -= 4;
200 _debug("token: [%x/%zx] %x", toklen, datalen, sec_ix);
201 paddedlen = (toklen + 3) & ~3;
202 if (toklen < 20 || toklen > datalen || paddedlen > datalen)
203 goto not_xdr;
204 datalen -= paddedlen;
205 p += paddedlen >> 2;
206
207 } while (--loop > 0);
208
209 _debug("remainder: %zu", datalen);
210 if (datalen != 0)
211 goto not_xdr;
212
213 /* okay: we're going to assume it's valid XDR format
214 * - we ignore the cellname, relying on the key to be correctly named
215 */
216 ret = -EPROTONOSUPPORT;
217 do {
218 toklen = ntohl(*xdr++);
219 token = xdr;
220 xdr += (toklen + 3) / 4;
221
222 sec_ix = ntohl(*token++);
223 toklen -= 4;
224
225 _debug("TOKEN type=%x len=%x", sec_ix, toklen);
226
227 switch (sec_ix) {
228 case RXRPC_SECURITY_RXKAD:
229 ret2 = rxrpc_preparse_xdr_rxkad(prep, datalen, token, toklen);
230 break;
231 default:
232 ret2 = -EPROTONOSUPPORT;
233 break;
234 }
235
236 switch (ret2) {
237 case 0:
238 ret = 0;
239 break;
240 case -EPROTONOSUPPORT:
241 break;
242 case -ENOPKG:
243 if (ret != 0)
244 ret = -ENOPKG;
245 break;
246 default:
247 ret = ret2;
248 goto error;
249 }
250
251 } while (--ntoken > 0);
252
253error:
254 _leave(" = %d", ret);
255 return ret;
256
257not_xdr:
258 _leave(" = -EPROTO");
259 return -EPROTO;
260}
261
262/*
263 * Preparse an rxrpc defined key.
264 *
265 * Data should be of the form:
266 * OFFSET LEN CONTENT
267 * 0 4 key interface version number
268 * 4 2 security index (type)
269 * 6 2 ticket length
270 * 8 4 key expiry time (time_t)
271 * 12 4 kvno
272 * 16 8 session key
273 * 24 [len] ticket
274 *
275 * if no data is provided, then a no-security key is made
276 */
277static int rxrpc_preparse(struct key_preparsed_payload *prep)
278{
279 const struct rxrpc_key_data_v1 *v1;
280 struct rxrpc_key_token *token, **pp;
281 time64_t expiry;
282 size_t plen;
283 u32 kver;
284 int ret;
285
286 _enter("%zu", prep->datalen);
287
288 /* handle a no-security key */
289 if (!prep->data && prep->datalen == 0)
290 return 0;
291
292 /* determine if the XDR payload format is being used */
293 if (prep->datalen > 7 * 4) {
294 ret = rxrpc_preparse_xdr(prep);
295 if (ret != -EPROTO)
296 return ret;
297 }
298
299 /* get the key interface version number */
300 ret = -EINVAL;
301 if (prep->datalen <= 4 || !prep->data)
302 goto error;
303 memcpy(&kver, prep->data, sizeof(kver));
304 prep->data += sizeof(kver);
305 prep->datalen -= sizeof(kver);
306
307 _debug("KEY I/F VERSION: %u", kver);
308
309 ret = -EKEYREJECTED;
310 if (kver != 1)
311 goto error;
312
313 /* deal with a version 1 key */
314 ret = -EINVAL;
315 if (prep->datalen < sizeof(*v1))
316 goto error;
317
318 v1 = prep->data;
319 if (prep->datalen != sizeof(*v1) + v1->ticket_length)
320 goto error;
321
322 _debug("SCIX: %u", v1->security_index);
323 _debug("TLEN: %u", v1->ticket_length);
324 _debug("EXPY: %x", v1->expiry);
325 _debug("KVNO: %u", v1->kvno);
326 _debug("SKEY: %02x%02x%02x%02x%02x%02x%02x%02x",
327 v1->session_key[0], v1->session_key[1],
328 v1->session_key[2], v1->session_key[3],
329 v1->session_key[4], v1->session_key[5],
330 v1->session_key[6], v1->session_key[7]);
331 if (v1->ticket_length >= 8)
332 _debug("TCKT: %02x%02x%02x%02x%02x%02x%02x%02x",
333 v1->ticket[0], v1->ticket[1],
334 v1->ticket[2], v1->ticket[3],
335 v1->ticket[4], v1->ticket[5],
336 v1->ticket[6], v1->ticket[7]);
337
338 ret = -EPROTONOSUPPORT;
339 if (v1->security_index != RXRPC_SECURITY_RXKAD)
340 goto error;
341
342 plen = sizeof(*token->kad) + v1->ticket_length;
343 prep->quotalen = plen + sizeof(*token);
344
345 ret = -ENOMEM;
346 token = kzalloc(sizeof(*token), GFP_KERNEL);
347 if (!token)
348 goto error;
349 token->kad = kzalloc(plen, GFP_KERNEL);
350 if (!token->kad)
351 goto error_free;
352
353 token->security_index = RXRPC_SECURITY_RXKAD;
354 token->kad->ticket_len = v1->ticket_length;
355 token->kad->expiry = v1->expiry;
356 token->kad->kvno = v1->kvno;
357 memcpy(&token->kad->session_key, &v1->session_key, 8);
358 memcpy(&token->kad->ticket, v1->ticket, v1->ticket_length);
359
360 /* count the number of tokens attached */
361 prep->payload.data[1] = (void *)((unsigned long)prep->payload.data[1] + 1);
362
363 /* attach the data */
364 pp = (struct rxrpc_key_token **)&prep->payload.data[0];
365 while (*pp)
366 pp = &(*pp)->next;
367 *pp = token;
368 expiry = rxrpc_u32_to_time64(token->kad->expiry);
369 if (expiry < prep->expiry)
370 prep->expiry = expiry;
371 token = NULL;
372 ret = 0;
373
374error_free:
375 kfree(token);
376error:
377 return ret;
378}
379
380/*
381 * Free token list.
382 */
383static void rxrpc_free_token_list(struct rxrpc_key_token *token)
384{
385 struct rxrpc_key_token *next;
386
387 for (; token; token = next) {
388 next = token->next;
389 switch (token->security_index) {
390 case RXRPC_SECURITY_RXKAD:
391 kfree(token->kad);
392 break;
393 default:
394 pr_err("Unknown token type %x on rxrpc key\n",
395 token->security_index);
396 BUG();
397 }
398
399 kfree(token);
400 }
401}
402
403/*
404 * Clean up preparse data.
405 */
406static void rxrpc_free_preparse(struct key_preparsed_payload *prep)
407{
408 rxrpc_free_token_list(prep->payload.data[0]);
409}
410
411/*
412 * dispose of the data dangling from the corpse of a rxrpc key
413 */
414static void rxrpc_destroy(struct key *key)
415{
416 rxrpc_free_token_list(key->payload.data[0]);
417}
418
419/*
420 * describe the rxrpc key
421 */
422static void rxrpc_describe(const struct key *key, struct seq_file *m)
423{
424 const struct rxrpc_key_token *token;
425 const char *sep = ": ";
426
427 seq_puts(m, key->description);
428
429 for (token = key->payload.data[0]; token; token = token->next) {
430 seq_puts(m, sep);
431
432 switch (token->security_index) {
433 case RXRPC_SECURITY_RXKAD:
434 seq_puts(m, "ka");
435 break;
436 default: /* we have a ticket we can't encode */
437 seq_printf(m, "%u", token->security_index);
438 break;
439 }
440
441 sep = " ";
442 }
443}
444
445/*
446 * grab the security key for a socket
447 */
448int rxrpc_request_key(struct rxrpc_sock *rx, sockptr_t optval, int optlen)
449{
450 struct key *key;
451 char *description;
452
453 _enter("");
454
455 if (optlen <= 0 || optlen > PAGE_SIZE - 1 || rx->securities)
456 return -EINVAL;
457
458 description = memdup_sockptr_nul(optval, optlen);
459 if (IS_ERR(description))
460 return PTR_ERR(description);
461
462 key = request_key_net(&key_type_rxrpc, description, sock_net(&rx->sk), NULL);
463 if (IS_ERR(key)) {
464 kfree(description);
465 _leave(" = %ld", PTR_ERR(key));
466 return PTR_ERR(key);
467 }
468
469 rx->key = key;
470 kfree(description);
471 _leave(" = 0 [key %x]", key->serial);
472 return 0;
473}
474
475/*
476 * generate a server data key
477 */
478int rxrpc_get_server_data_key(struct rxrpc_connection *conn,
479 const void *session_key,
480 time64_t expiry,
481 u32 kvno)
482{
483 const struct cred *cred = current_cred();
484 struct key *key;
485 int ret;
486
487 struct {
488 u32 kver;
489 struct rxrpc_key_data_v1 v1;
490 } data;
491
492 _enter("");
493
494 key = key_alloc(&key_type_rxrpc, "x",
495 GLOBAL_ROOT_UID, GLOBAL_ROOT_GID, cred, 0,
496 KEY_ALLOC_NOT_IN_QUOTA, NULL);
497 if (IS_ERR(key)) {
498 _leave(" = -ENOMEM [alloc %ld]", PTR_ERR(key));
499 return -ENOMEM;
500 }
501
502 _debug("key %d", key_serial(key));
503
504 data.kver = 1;
505 data.v1.security_index = RXRPC_SECURITY_RXKAD;
506 data.v1.ticket_length = 0;
507 data.v1.expiry = rxrpc_time64_to_u32(expiry);
508 data.v1.kvno = 0;
509
510 memcpy(&data.v1.session_key, session_key, sizeof(data.v1.session_key));
511
512 ret = key_instantiate_and_link(key, &data, sizeof(data), NULL, NULL);
513 if (ret < 0)
514 goto error;
515
516 conn->key = key;
517 _leave(" = 0 [%d]", key_serial(key));
518 return 0;
519
520error:
521 key_revoke(key);
522 key_put(key);
523 _leave(" = -ENOMEM [ins %d]", ret);
524 return -ENOMEM;
525}
526EXPORT_SYMBOL(rxrpc_get_server_data_key);
527
528/**
529 * rxrpc_get_null_key - Generate a null RxRPC key
530 * @keyname: The name to give the key.
531 *
532 * Generate a null RxRPC key that can be used to indicate anonymous security is
533 * required for a particular domain.
534 */
535struct key *rxrpc_get_null_key(const char *keyname)
536{
537 const struct cred *cred = current_cred();
538 struct key *key;
539 int ret;
540
541 key = key_alloc(&key_type_rxrpc, keyname,
542 GLOBAL_ROOT_UID, GLOBAL_ROOT_GID, cred,
543 KEY_POS_SEARCH, KEY_ALLOC_NOT_IN_QUOTA, NULL);
544 if (IS_ERR(key))
545 return key;
546
547 ret = key_instantiate_and_link(key, NULL, 0, NULL, NULL);
548 if (ret < 0) {
549 key_revoke(key);
550 key_put(key);
551 return ERR_PTR(ret);
552 }
553
554 return key;
555}
556EXPORT_SYMBOL(rxrpc_get_null_key);
557
558/*
559 * read the contents of an rxrpc key
560 * - this returns the result in XDR form
561 */
562static long rxrpc_read(const struct key *key,
563 char *buffer, size_t buflen)
564{
565 const struct rxrpc_key_token *token;
566 size_t size;
567 __be32 *xdr, *oldxdr;
568 u32 cnlen, toksize, ntoks, tok, zero;
569 u16 toksizes[AFSTOKEN_MAX];
570
571 _enter("");
572
573 /* we don't know what form we should return non-AFS keys in */
574 if (memcmp(key->description, "afs@", 4) != 0)
575 return -EOPNOTSUPP;
576 cnlen = strlen(key->description + 4);
577
578#define RND(X) (((X) + 3) & ~3)
579
580 /* AFS keys we return in XDR form, so we need to work out the size of
581 * the XDR */
582 size = 2 * 4; /* flags, cellname len */
583 size += RND(cnlen); /* cellname */
584 size += 1 * 4; /* token count */
585
586 ntoks = 0;
587 for (token = key->payload.data[0]; token; token = token->next) {
588 toksize = 4; /* sec index */
589
590 switch (token->security_index) {
591 case RXRPC_SECURITY_RXKAD:
592 toksize += 8 * 4; /* viceid, kvno, key*2, begin,
593 * end, primary, tktlen */
594 if (!token->no_leak_key)
595 toksize += RND(token->kad->ticket_len);
596 break;
597
598 default: /* we have a ticket we can't encode */
599 pr_err("Unsupported key token type (%u)\n",
600 token->security_index);
601 return -ENOPKG;
602 }
603
604 _debug("token[%u]: toksize=%u", ntoks, toksize);
605 if (WARN_ON(toksize > AFSTOKEN_LENGTH_MAX))
606 return -EIO;
607
608 toksizes[ntoks++] = toksize;
609 size += toksize + 4; /* each token has a length word */
610 }
611
612#undef RND
613
614 if (!buffer || buflen < size)
615 return size;
616
617 xdr = (__be32 *)buffer;
618 zero = 0;
619#define ENCODE(x) \
620 do { \
621 *xdr++ = htonl(x); \
622 } while(0)
623#define ENCODE_DATA(l, s) \
624 do { \
625 u32 _l = (l); \
626 ENCODE(l); \
627 memcpy(xdr, (s), _l); \
628 if (_l & 3) \
629 memcpy((u8 *)xdr + _l, &zero, 4 - (_l & 3)); \
630 xdr += (_l + 3) >> 2; \
631 } while(0)
632#define ENCODE_BYTES(l, s) \
633 do { \
634 u32 _l = (l); \
635 memcpy(xdr, (s), _l); \
636 if (_l & 3) \
637 memcpy((u8 *)xdr + _l, &zero, 4 - (_l & 3)); \
638 xdr += (_l + 3) >> 2; \
639 } while(0)
640#define ENCODE64(x) \
641 do { \
642 __be64 y = cpu_to_be64(x); \
643 memcpy(xdr, &y, 8); \
644 xdr += 8 >> 2; \
645 } while(0)
646#define ENCODE_STR(s) \
647 do { \
648 const char *_s = (s); \
649 ENCODE_DATA(strlen(_s), _s); \
650 } while(0)
651
652 ENCODE(0); /* flags */
653 ENCODE_DATA(cnlen, key->description + 4); /* cellname */
654 ENCODE(ntoks);
655
656 tok = 0;
657 for (token = key->payload.data[0]; token; token = token->next) {
658 toksize = toksizes[tok++];
659 ENCODE(toksize);
660 oldxdr = xdr;
661 ENCODE(token->security_index);
662
663 switch (token->security_index) {
664 case RXRPC_SECURITY_RXKAD:
665 ENCODE(token->kad->vice_id);
666 ENCODE(token->kad->kvno);
667 ENCODE_BYTES(8, token->kad->session_key);
668 ENCODE(token->kad->start);
669 ENCODE(token->kad->expiry);
670 ENCODE(token->kad->primary_flag);
671 if (token->no_leak_key)
672 ENCODE(0);
673 else
674 ENCODE_DATA(token->kad->ticket_len, token->kad->ticket);
675 break;
676
677 default:
678 pr_err("Unsupported key token type (%u)\n",
679 token->security_index);
680 return -ENOPKG;
681 }
682
683 if (WARN_ON((unsigned long)xdr - (unsigned long)oldxdr ==
684 toksize))
685 return -EIO;
686 }
687
688#undef ENCODE_STR
689#undef ENCODE_DATA
690#undef ENCODE64
691#undef ENCODE
692
693 if (WARN_ON(tok != ntoks))
694 return -EIO;
695 if (WARN_ON((unsigned long)xdr - (unsigned long)buffer != size))
696 return -EIO;
697 _leave(" = %zu", size);
698 return size;
699}
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#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
16
17#include <crypto/skcipher.h>
18#include <linux/module.h>
19#include <linux/net.h>
20#include <linux/skbuff.h>
21#include <linux/key-type.h>
22#include <linux/ctype.h>
23#include <linux/slab.h>
24#include <net/sock.h>
25#include <net/af_rxrpc.h>
26#include <keys/rxrpc-type.h>
27#include <keys/user-type.h>
28#include "ar-internal.h"
29
30static int rxrpc_vet_description_s(const char *);
31static int rxrpc_preparse(struct key_preparsed_payload *);
32static int rxrpc_preparse_s(struct key_preparsed_payload *);
33static void rxrpc_free_preparse(struct key_preparsed_payload *);
34static void rxrpc_free_preparse_s(struct key_preparsed_payload *);
35static void rxrpc_destroy(struct key *);
36static void rxrpc_destroy_s(struct key *);
37static void rxrpc_describe(const struct key *, struct seq_file *);
38static long rxrpc_read(const struct key *, char __user *, size_t);
39
40/*
41 * rxrpc defined keys take an arbitrary string as the description and an
42 * arbitrary blob of data as the payload
43 */
44struct key_type key_type_rxrpc = {
45 .name = "rxrpc",
46 .preparse = rxrpc_preparse,
47 .free_preparse = rxrpc_free_preparse,
48 .instantiate = generic_key_instantiate,
49 .destroy = rxrpc_destroy,
50 .describe = rxrpc_describe,
51 .read = rxrpc_read,
52};
53EXPORT_SYMBOL(key_type_rxrpc);
54
55/*
56 * rxrpc server defined keys take "<serviceId>:<securityIndex>" as the
57 * description and an 8-byte decryption key as the payload
58 */
59struct key_type key_type_rxrpc_s = {
60 .name = "rxrpc_s",
61 .vet_description = rxrpc_vet_description_s,
62 .preparse = rxrpc_preparse_s,
63 .free_preparse = rxrpc_free_preparse_s,
64 .instantiate = generic_key_instantiate,
65 .destroy = rxrpc_destroy_s,
66 .describe = rxrpc_describe,
67};
68
69/*
70 * Vet the description for an RxRPC server key
71 */
72static int rxrpc_vet_description_s(const char *desc)
73{
74 unsigned long num;
75 char *p;
76
77 num = simple_strtoul(desc, &p, 10);
78 if (*p != ':' || num > 65535)
79 return -EINVAL;
80 num = simple_strtoul(p + 1, &p, 10);
81 if (*p || num < 1 || num > 255)
82 return -EINVAL;
83 return 0;
84}
85
86/*
87 * parse an RxKAD type XDR format token
88 * - the caller guarantees we have at least 4 words
89 */
90static int rxrpc_preparse_xdr_rxkad(struct key_preparsed_payload *prep,
91 size_t datalen,
92 const __be32 *xdr, unsigned int toklen)
93{
94 struct rxrpc_key_token *token, **pptoken;
95 time64_t expiry;
96 size_t plen;
97 u32 tktlen;
98
99 _enter(",{%x,%x,%x,%x},%u",
100 ntohl(xdr[0]), ntohl(xdr[1]), ntohl(xdr[2]), ntohl(xdr[3]),
101 toklen);
102
103 if (toklen <= 8 * 4)
104 return -EKEYREJECTED;
105 tktlen = ntohl(xdr[7]);
106 _debug("tktlen: %x", tktlen);
107 if (tktlen > AFSTOKEN_RK_TIX_MAX)
108 return -EKEYREJECTED;
109 if (toklen < 8 * 4 + tktlen)
110 return -EKEYREJECTED;
111
112 plen = sizeof(*token) + sizeof(*token->kad) + tktlen;
113 prep->quotalen = datalen + plen;
114
115 plen -= sizeof(*token);
116 token = kzalloc(sizeof(*token), GFP_KERNEL);
117 if (!token)
118 return -ENOMEM;
119
120 token->kad = kzalloc(plen, GFP_KERNEL);
121 if (!token->kad) {
122 kfree(token);
123 return -ENOMEM;
124 }
125
126 token->security_index = RXRPC_SECURITY_RXKAD;
127 token->kad->ticket_len = tktlen;
128 token->kad->vice_id = ntohl(xdr[0]);
129 token->kad->kvno = ntohl(xdr[1]);
130 token->kad->start = ntohl(xdr[4]);
131 token->kad->expiry = ntohl(xdr[5]);
132 token->kad->primary_flag = ntohl(xdr[6]);
133 memcpy(&token->kad->session_key, &xdr[2], 8);
134 memcpy(&token->kad->ticket, &xdr[8], tktlen);
135
136 _debug("SCIX: %u", token->security_index);
137 _debug("TLEN: %u", token->kad->ticket_len);
138 _debug("EXPY: %x", token->kad->expiry);
139 _debug("KVNO: %u", token->kad->kvno);
140 _debug("PRIM: %u", token->kad->primary_flag);
141 _debug("SKEY: %02x%02x%02x%02x%02x%02x%02x%02x",
142 token->kad->session_key[0], token->kad->session_key[1],
143 token->kad->session_key[2], token->kad->session_key[3],
144 token->kad->session_key[4], token->kad->session_key[5],
145 token->kad->session_key[6], token->kad->session_key[7]);
146 if (token->kad->ticket_len >= 8)
147 _debug("TCKT: %02x%02x%02x%02x%02x%02x%02x%02x",
148 token->kad->ticket[0], token->kad->ticket[1],
149 token->kad->ticket[2], token->kad->ticket[3],
150 token->kad->ticket[4], token->kad->ticket[5],
151 token->kad->ticket[6], token->kad->ticket[7]);
152
153 /* count the number of tokens attached */
154 prep->payload.data[1] = (void *)((unsigned long)prep->payload.data[1] + 1);
155
156 /* attach the data */
157 for (pptoken = (struct rxrpc_key_token **)&prep->payload.data[0];
158 *pptoken;
159 pptoken = &(*pptoken)->next)
160 continue;
161 *pptoken = token;
162 expiry = rxrpc_u32_to_time64(token->kad->expiry);
163 if (expiry < prep->expiry)
164 prep->expiry = expiry;
165
166 _leave(" = 0");
167 return 0;
168}
169
170static void rxrpc_free_krb5_principal(struct krb5_principal *princ)
171{
172 int loop;
173
174 if (princ->name_parts) {
175 for (loop = princ->n_name_parts - 1; loop >= 0; loop--)
176 kfree(princ->name_parts[loop]);
177 kfree(princ->name_parts);
178 }
179 kfree(princ->realm);
180}
181
182static void rxrpc_free_krb5_tagged(struct krb5_tagged_data *td)
183{
184 kfree(td->data);
185}
186
187/*
188 * free up an RxK5 token
189 */
190static void rxrpc_rxk5_free(struct rxk5_key *rxk5)
191{
192 int loop;
193
194 rxrpc_free_krb5_principal(&rxk5->client);
195 rxrpc_free_krb5_principal(&rxk5->server);
196 rxrpc_free_krb5_tagged(&rxk5->session);
197
198 if (rxk5->addresses) {
199 for (loop = rxk5->n_addresses - 1; loop >= 0; loop--)
200 rxrpc_free_krb5_tagged(&rxk5->addresses[loop]);
201 kfree(rxk5->addresses);
202 }
203 if (rxk5->authdata) {
204 for (loop = rxk5->n_authdata - 1; loop >= 0; loop--)
205 rxrpc_free_krb5_tagged(&rxk5->authdata[loop]);
206 kfree(rxk5->authdata);
207 }
208
209 kfree(rxk5->ticket);
210 kfree(rxk5->ticket2);
211 kfree(rxk5);
212}
213
214/*
215 * extract a krb5 principal
216 */
217static int rxrpc_krb5_decode_principal(struct krb5_principal *princ,
218 const __be32 **_xdr,
219 unsigned int *_toklen)
220{
221 const __be32 *xdr = *_xdr;
222 unsigned int toklen = *_toklen, n_parts, loop, tmp, paddedlen;
223
224 /* there must be at least one name, and at least #names+1 length
225 * words */
226 if (toklen <= 12)
227 return -EINVAL;
228
229 _enter(",{%x,%x,%x},%u",
230 ntohl(xdr[0]), ntohl(xdr[1]), ntohl(xdr[2]), toklen);
231
232 n_parts = ntohl(*xdr++);
233 toklen -= 4;
234 if (n_parts <= 0 || n_parts > AFSTOKEN_K5_COMPONENTS_MAX)
235 return -EINVAL;
236 princ->n_name_parts = n_parts;
237
238 if (toklen <= (n_parts + 1) * 4)
239 return -EINVAL;
240
241 princ->name_parts = kcalloc(n_parts, sizeof(char *), GFP_KERNEL);
242 if (!princ->name_parts)
243 return -ENOMEM;
244
245 for (loop = 0; loop < n_parts; loop++) {
246 if (toklen < 4)
247 return -EINVAL;
248 tmp = ntohl(*xdr++);
249 toklen -= 4;
250 if (tmp <= 0 || tmp > AFSTOKEN_STRING_MAX)
251 return -EINVAL;
252 paddedlen = (tmp + 3) & ~3;
253 if (paddedlen > toklen)
254 return -EINVAL;
255 princ->name_parts[loop] = kmalloc(tmp + 1, GFP_KERNEL);
256 if (!princ->name_parts[loop])
257 return -ENOMEM;
258 memcpy(princ->name_parts[loop], xdr, tmp);
259 princ->name_parts[loop][tmp] = 0;
260 toklen -= paddedlen;
261 xdr += paddedlen >> 2;
262 }
263
264 if (toklen < 4)
265 return -EINVAL;
266 tmp = ntohl(*xdr++);
267 toklen -= 4;
268 if (tmp <= 0 || tmp > AFSTOKEN_K5_REALM_MAX)
269 return -EINVAL;
270 paddedlen = (tmp + 3) & ~3;
271 if (paddedlen > toklen)
272 return -EINVAL;
273 princ->realm = kmalloc(tmp + 1, GFP_KERNEL);
274 if (!princ->realm)
275 return -ENOMEM;
276 memcpy(princ->realm, xdr, tmp);
277 princ->realm[tmp] = 0;
278 toklen -= paddedlen;
279 xdr += paddedlen >> 2;
280
281 _debug("%s/...@%s", princ->name_parts[0], princ->realm);
282
283 *_xdr = xdr;
284 *_toklen = toklen;
285 _leave(" = 0 [toklen=%u]", toklen);
286 return 0;
287}
288
289/*
290 * extract a piece of krb5 tagged data
291 */
292static int rxrpc_krb5_decode_tagged_data(struct krb5_tagged_data *td,
293 size_t max_data_size,
294 const __be32 **_xdr,
295 unsigned int *_toklen)
296{
297 const __be32 *xdr = *_xdr;
298 unsigned int toklen = *_toklen, len, paddedlen;
299
300 /* there must be at least one tag and one length word */
301 if (toklen <= 8)
302 return -EINVAL;
303
304 _enter(",%zu,{%x,%x},%u",
305 max_data_size, ntohl(xdr[0]), ntohl(xdr[1]), toklen);
306
307 td->tag = ntohl(*xdr++);
308 len = ntohl(*xdr++);
309 toklen -= 8;
310 if (len > max_data_size)
311 return -EINVAL;
312 paddedlen = (len + 3) & ~3;
313 if (paddedlen > toklen)
314 return -EINVAL;
315 td->data_len = len;
316
317 if (len > 0) {
318 td->data = kmemdup(xdr, len, GFP_KERNEL);
319 if (!td->data)
320 return -ENOMEM;
321 toklen -= paddedlen;
322 xdr += paddedlen >> 2;
323 }
324
325 _debug("tag %x len %x", td->tag, td->data_len);
326
327 *_xdr = xdr;
328 *_toklen = toklen;
329 _leave(" = 0 [toklen=%u]", toklen);
330 return 0;
331}
332
333/*
334 * extract an array of tagged data
335 */
336static int rxrpc_krb5_decode_tagged_array(struct krb5_tagged_data **_td,
337 u8 *_n_elem,
338 u8 max_n_elem,
339 size_t max_elem_size,
340 const __be32 **_xdr,
341 unsigned int *_toklen)
342{
343 struct krb5_tagged_data *td;
344 const __be32 *xdr = *_xdr;
345 unsigned int toklen = *_toklen, n_elem, loop;
346 int ret;
347
348 /* there must be at least one count */
349 if (toklen < 4)
350 return -EINVAL;
351
352 _enter(",,%u,%zu,{%x},%u",
353 max_n_elem, max_elem_size, ntohl(xdr[0]), toklen);
354
355 n_elem = ntohl(*xdr++);
356 toklen -= 4;
357 if (n_elem > max_n_elem)
358 return -EINVAL;
359 *_n_elem = n_elem;
360 if (n_elem > 0) {
361 if (toklen <= (n_elem + 1) * 4)
362 return -EINVAL;
363
364 _debug("n_elem %d", n_elem);
365
366 td = kcalloc(n_elem, sizeof(struct krb5_tagged_data),
367 GFP_KERNEL);
368 if (!td)
369 return -ENOMEM;
370 *_td = td;
371
372 for (loop = 0; loop < n_elem; loop++) {
373 ret = rxrpc_krb5_decode_tagged_data(&td[loop],
374 max_elem_size,
375 &xdr, &toklen);
376 if (ret < 0)
377 return ret;
378 }
379 }
380
381 *_xdr = xdr;
382 *_toklen = toklen;
383 _leave(" = 0 [toklen=%u]", toklen);
384 return 0;
385}
386
387/*
388 * extract a krb5 ticket
389 */
390static int rxrpc_krb5_decode_ticket(u8 **_ticket, u16 *_tktlen,
391 const __be32 **_xdr, unsigned int *_toklen)
392{
393 const __be32 *xdr = *_xdr;
394 unsigned int toklen = *_toklen, len, paddedlen;
395
396 /* there must be at least one length word */
397 if (toklen <= 4)
398 return -EINVAL;
399
400 _enter(",{%x},%u", ntohl(xdr[0]), toklen);
401
402 len = ntohl(*xdr++);
403 toklen -= 4;
404 if (len > AFSTOKEN_K5_TIX_MAX)
405 return -EINVAL;
406 paddedlen = (len + 3) & ~3;
407 if (paddedlen > toklen)
408 return -EINVAL;
409 *_tktlen = len;
410
411 _debug("ticket len %u", len);
412
413 if (len > 0) {
414 *_ticket = kmemdup(xdr, len, GFP_KERNEL);
415 if (!*_ticket)
416 return -ENOMEM;
417 toklen -= paddedlen;
418 xdr += paddedlen >> 2;
419 }
420
421 *_xdr = xdr;
422 *_toklen = toklen;
423 _leave(" = 0 [toklen=%u]", toklen);
424 return 0;
425}
426
427/*
428 * parse an RxK5 type XDR format token
429 * - the caller guarantees we have at least 4 words
430 */
431static int rxrpc_preparse_xdr_rxk5(struct key_preparsed_payload *prep,
432 size_t datalen,
433 const __be32 *xdr, unsigned int toklen)
434{
435 struct rxrpc_key_token *token, **pptoken;
436 struct rxk5_key *rxk5;
437 const __be32 *end_xdr = xdr + (toklen >> 2);
438 time64_t expiry;
439 int ret;
440
441 _enter(",{%x,%x,%x,%x},%u",
442 ntohl(xdr[0]), ntohl(xdr[1]), ntohl(xdr[2]), ntohl(xdr[3]),
443 toklen);
444
445 /* reserve some payload space for this subkey - the length of the token
446 * is a reasonable approximation */
447 prep->quotalen = datalen + toklen;
448
449 token = kzalloc(sizeof(*token), GFP_KERNEL);
450 if (!token)
451 return -ENOMEM;
452
453 rxk5 = kzalloc(sizeof(*rxk5), GFP_KERNEL);
454 if (!rxk5) {
455 kfree(token);
456 return -ENOMEM;
457 }
458
459 token->security_index = RXRPC_SECURITY_RXK5;
460 token->k5 = rxk5;
461
462 /* extract the principals */
463 ret = rxrpc_krb5_decode_principal(&rxk5->client, &xdr, &toklen);
464 if (ret < 0)
465 goto error;
466 ret = rxrpc_krb5_decode_principal(&rxk5->server, &xdr, &toklen);
467 if (ret < 0)
468 goto error;
469
470 /* extract the session key and the encoding type (the tag field ->
471 * ENCTYPE_xxx) */
472 ret = rxrpc_krb5_decode_tagged_data(&rxk5->session, AFSTOKEN_DATA_MAX,
473 &xdr, &toklen);
474 if (ret < 0)
475 goto error;
476
477 if (toklen < 4 * 8 + 2 * 4)
478 goto inval;
479 rxk5->authtime = be64_to_cpup((const __be64 *) xdr);
480 xdr += 2;
481 rxk5->starttime = be64_to_cpup((const __be64 *) xdr);
482 xdr += 2;
483 rxk5->endtime = be64_to_cpup((const __be64 *) xdr);
484 xdr += 2;
485 rxk5->renew_till = be64_to_cpup((const __be64 *) xdr);
486 xdr += 2;
487 rxk5->is_skey = ntohl(*xdr++);
488 rxk5->flags = ntohl(*xdr++);
489 toklen -= 4 * 8 + 2 * 4;
490
491 _debug("times: a=%llx s=%llx e=%llx rt=%llx",
492 rxk5->authtime, rxk5->starttime, rxk5->endtime,
493 rxk5->renew_till);
494 _debug("is_skey=%x flags=%x", rxk5->is_skey, rxk5->flags);
495
496 /* extract the permitted client addresses */
497 ret = rxrpc_krb5_decode_tagged_array(&rxk5->addresses,
498 &rxk5->n_addresses,
499 AFSTOKEN_K5_ADDRESSES_MAX,
500 AFSTOKEN_DATA_MAX,
501 &xdr, &toklen);
502 if (ret < 0)
503 goto error;
504
505 ASSERTCMP((end_xdr - xdr) << 2, ==, toklen);
506
507 /* extract the tickets */
508 ret = rxrpc_krb5_decode_ticket(&rxk5->ticket, &rxk5->ticket_len,
509 &xdr, &toklen);
510 if (ret < 0)
511 goto error;
512 ret = rxrpc_krb5_decode_ticket(&rxk5->ticket2, &rxk5->ticket2_len,
513 &xdr, &toklen);
514 if (ret < 0)
515 goto error;
516
517 ASSERTCMP((end_xdr - xdr) << 2, ==, toklen);
518
519 /* extract the typed auth data */
520 ret = rxrpc_krb5_decode_tagged_array(&rxk5->authdata,
521 &rxk5->n_authdata,
522 AFSTOKEN_K5_AUTHDATA_MAX,
523 AFSTOKEN_BDATALN_MAX,
524 &xdr, &toklen);
525 if (ret < 0)
526 goto error;
527
528 ASSERTCMP((end_xdr - xdr) << 2, ==, toklen);
529
530 if (toklen != 0)
531 goto inval;
532
533 /* attach the payload */
534 for (pptoken = (struct rxrpc_key_token **)&prep->payload.data[0];
535 *pptoken;
536 pptoken = &(*pptoken)->next)
537 continue;
538 *pptoken = token;
539 expiry = rxrpc_u32_to_time64(token->k5->endtime);
540 if (expiry < prep->expiry)
541 prep->expiry = expiry;
542
543 _leave(" = 0");
544 return 0;
545
546inval:
547 ret = -EINVAL;
548error:
549 rxrpc_rxk5_free(rxk5);
550 kfree(token);
551 _leave(" = %d", ret);
552 return ret;
553}
554
555/*
556 * attempt to parse the data as the XDR format
557 * - the caller guarantees we have more than 7 words
558 */
559static int rxrpc_preparse_xdr(struct key_preparsed_payload *prep)
560{
561 const __be32 *xdr = prep->data, *token;
562 const char *cp;
563 unsigned int len, paddedlen, loop, ntoken, toklen, sec_ix;
564 size_t datalen = prep->datalen;
565 int ret;
566
567 _enter(",{%x,%x,%x,%x},%zu",
568 ntohl(xdr[0]), ntohl(xdr[1]), ntohl(xdr[2]), ntohl(xdr[3]),
569 prep->datalen);
570
571 if (datalen > AFSTOKEN_LENGTH_MAX)
572 goto not_xdr;
573
574 /* XDR is an array of __be32's */
575 if (datalen & 3)
576 goto not_xdr;
577
578 /* the flags should be 0 (the setpag bit must be handled by
579 * userspace) */
580 if (ntohl(*xdr++) != 0)
581 goto not_xdr;
582 datalen -= 4;
583
584 /* check the cell name */
585 len = ntohl(*xdr++);
586 if (len < 1 || len > AFSTOKEN_CELL_MAX)
587 goto not_xdr;
588 datalen -= 4;
589 paddedlen = (len + 3) & ~3;
590 if (paddedlen > datalen)
591 goto not_xdr;
592
593 cp = (const char *) xdr;
594 for (loop = 0; loop < len; loop++)
595 if (!isprint(cp[loop]))
596 goto not_xdr;
597 for (; loop < paddedlen; loop++)
598 if (cp[loop])
599 goto not_xdr;
600 _debug("cellname: [%u/%u] '%*.*s'",
601 len, paddedlen, len, len, (const char *) xdr);
602 datalen -= paddedlen;
603 xdr += paddedlen >> 2;
604
605 /* get the token count */
606 if (datalen < 12)
607 goto not_xdr;
608 ntoken = ntohl(*xdr++);
609 datalen -= 4;
610 _debug("ntoken: %x", ntoken);
611 if (ntoken < 1 || ntoken > AFSTOKEN_MAX)
612 goto not_xdr;
613
614 /* check each token wrapper */
615 token = xdr;
616 loop = ntoken;
617 do {
618 if (datalen < 8)
619 goto not_xdr;
620 toklen = ntohl(*xdr++);
621 sec_ix = ntohl(*xdr);
622 datalen -= 4;
623 _debug("token: [%x/%zx] %x", toklen, datalen, sec_ix);
624 paddedlen = (toklen + 3) & ~3;
625 if (toklen < 20 || toklen > datalen || paddedlen > datalen)
626 goto not_xdr;
627 datalen -= paddedlen;
628 xdr += paddedlen >> 2;
629
630 } while (--loop > 0);
631
632 _debug("remainder: %zu", datalen);
633 if (datalen != 0)
634 goto not_xdr;
635
636 /* okay: we're going to assume it's valid XDR format
637 * - we ignore the cellname, relying on the key to be correctly named
638 */
639 do {
640 xdr = token;
641 toklen = ntohl(*xdr++);
642 token = xdr + ((toklen + 3) >> 2);
643 sec_ix = ntohl(*xdr++);
644 toklen -= 4;
645
646 _debug("TOKEN type=%u [%p-%p]", sec_ix, xdr, token);
647
648 switch (sec_ix) {
649 case RXRPC_SECURITY_RXKAD:
650 ret = rxrpc_preparse_xdr_rxkad(prep, datalen, xdr, toklen);
651 if (ret != 0)
652 goto error;
653 break;
654
655 case RXRPC_SECURITY_RXK5:
656 ret = rxrpc_preparse_xdr_rxk5(prep, datalen, xdr, toklen);
657 if (ret != 0)
658 goto error;
659 break;
660
661 default:
662 ret = -EPROTONOSUPPORT;
663 goto error;
664 }
665
666 } while (--ntoken > 0);
667
668 _leave(" = 0");
669 return 0;
670
671not_xdr:
672 _leave(" = -EPROTO");
673 return -EPROTO;
674error:
675 _leave(" = %d", ret);
676 return ret;
677}
678
679/*
680 * Preparse an rxrpc defined key.
681 *
682 * Data should be of the form:
683 * OFFSET LEN CONTENT
684 * 0 4 key interface version number
685 * 4 2 security index (type)
686 * 6 2 ticket length
687 * 8 4 key expiry time (time_t)
688 * 12 4 kvno
689 * 16 8 session key
690 * 24 [len] ticket
691 *
692 * if no data is provided, then a no-security key is made
693 */
694static int rxrpc_preparse(struct key_preparsed_payload *prep)
695{
696 const struct rxrpc_key_data_v1 *v1;
697 struct rxrpc_key_token *token, **pp;
698 time64_t expiry;
699 size_t plen;
700 u32 kver;
701 int ret;
702
703 _enter("%zu", prep->datalen);
704
705 /* handle a no-security key */
706 if (!prep->data && prep->datalen == 0)
707 return 0;
708
709 /* determine if the XDR payload format is being used */
710 if (prep->datalen > 7 * 4) {
711 ret = rxrpc_preparse_xdr(prep);
712 if (ret != -EPROTO)
713 return ret;
714 }
715
716 /* get the key interface version number */
717 ret = -EINVAL;
718 if (prep->datalen <= 4 || !prep->data)
719 goto error;
720 memcpy(&kver, prep->data, sizeof(kver));
721 prep->data += sizeof(kver);
722 prep->datalen -= sizeof(kver);
723
724 _debug("KEY I/F VERSION: %u", kver);
725
726 ret = -EKEYREJECTED;
727 if (kver != 1)
728 goto error;
729
730 /* deal with a version 1 key */
731 ret = -EINVAL;
732 if (prep->datalen < sizeof(*v1))
733 goto error;
734
735 v1 = prep->data;
736 if (prep->datalen != sizeof(*v1) + v1->ticket_length)
737 goto error;
738
739 _debug("SCIX: %u", v1->security_index);
740 _debug("TLEN: %u", v1->ticket_length);
741 _debug("EXPY: %x", v1->expiry);
742 _debug("KVNO: %u", v1->kvno);
743 _debug("SKEY: %02x%02x%02x%02x%02x%02x%02x%02x",
744 v1->session_key[0], v1->session_key[1],
745 v1->session_key[2], v1->session_key[3],
746 v1->session_key[4], v1->session_key[5],
747 v1->session_key[6], v1->session_key[7]);
748 if (v1->ticket_length >= 8)
749 _debug("TCKT: %02x%02x%02x%02x%02x%02x%02x%02x",
750 v1->ticket[0], v1->ticket[1],
751 v1->ticket[2], v1->ticket[3],
752 v1->ticket[4], v1->ticket[5],
753 v1->ticket[6], v1->ticket[7]);
754
755 ret = -EPROTONOSUPPORT;
756 if (v1->security_index != RXRPC_SECURITY_RXKAD)
757 goto error;
758
759 plen = sizeof(*token->kad) + v1->ticket_length;
760 prep->quotalen = plen + sizeof(*token);
761
762 ret = -ENOMEM;
763 token = kzalloc(sizeof(*token), GFP_KERNEL);
764 if (!token)
765 goto error;
766 token->kad = kzalloc(plen, GFP_KERNEL);
767 if (!token->kad)
768 goto error_free;
769
770 token->security_index = RXRPC_SECURITY_RXKAD;
771 token->kad->ticket_len = v1->ticket_length;
772 token->kad->expiry = v1->expiry;
773 token->kad->kvno = v1->kvno;
774 memcpy(&token->kad->session_key, &v1->session_key, 8);
775 memcpy(&token->kad->ticket, v1->ticket, v1->ticket_length);
776
777 /* count the number of tokens attached */
778 prep->payload.data[1] = (void *)((unsigned long)prep->payload.data[1] + 1);
779
780 /* attach the data */
781 pp = (struct rxrpc_key_token **)&prep->payload.data[0];
782 while (*pp)
783 pp = &(*pp)->next;
784 *pp = token;
785 expiry = rxrpc_u32_to_time64(token->kad->expiry);
786 if (expiry < prep->expiry)
787 prep->expiry = expiry;
788 token = NULL;
789 ret = 0;
790
791error_free:
792 kfree(token);
793error:
794 return ret;
795}
796
797/*
798 * Free token list.
799 */
800static void rxrpc_free_token_list(struct rxrpc_key_token *token)
801{
802 struct rxrpc_key_token *next;
803
804 for (; token; token = next) {
805 next = token->next;
806 switch (token->security_index) {
807 case RXRPC_SECURITY_RXKAD:
808 kfree(token->kad);
809 break;
810 case RXRPC_SECURITY_RXK5:
811 if (token->k5)
812 rxrpc_rxk5_free(token->k5);
813 break;
814 default:
815 pr_err("Unknown token type %x on rxrpc key\n",
816 token->security_index);
817 BUG();
818 }
819
820 kfree(token);
821 }
822}
823
824/*
825 * Clean up preparse data.
826 */
827static void rxrpc_free_preparse(struct key_preparsed_payload *prep)
828{
829 rxrpc_free_token_list(prep->payload.data[0]);
830}
831
832/*
833 * Preparse a server secret key.
834 *
835 * The data should be the 8-byte secret key.
836 */
837static int rxrpc_preparse_s(struct key_preparsed_payload *prep)
838{
839 struct crypto_skcipher *ci;
840
841 _enter("%zu", prep->datalen);
842
843 if (prep->datalen != 8)
844 return -EINVAL;
845
846 memcpy(&prep->payload.data[2], prep->data, 8);
847
848 ci = crypto_alloc_skcipher("pcbc(des)", 0, CRYPTO_ALG_ASYNC);
849 if (IS_ERR(ci)) {
850 _leave(" = %ld", PTR_ERR(ci));
851 return PTR_ERR(ci);
852 }
853
854 if (crypto_skcipher_setkey(ci, prep->data, 8) < 0)
855 BUG();
856
857 prep->payload.data[0] = ci;
858 _leave(" = 0");
859 return 0;
860}
861
862/*
863 * Clean up preparse data.
864 */
865static void rxrpc_free_preparse_s(struct key_preparsed_payload *prep)
866{
867 if (prep->payload.data[0])
868 crypto_free_skcipher(prep->payload.data[0]);
869}
870
871/*
872 * dispose of the data dangling from the corpse of a rxrpc key
873 */
874static void rxrpc_destroy(struct key *key)
875{
876 rxrpc_free_token_list(key->payload.data[0]);
877}
878
879/*
880 * dispose of the data dangling from the corpse of a rxrpc key
881 */
882static void rxrpc_destroy_s(struct key *key)
883{
884 if (key->payload.data[0]) {
885 crypto_free_skcipher(key->payload.data[0]);
886 key->payload.data[0] = NULL;
887 }
888}
889
890/*
891 * describe the rxrpc key
892 */
893static void rxrpc_describe(const struct key *key, struct seq_file *m)
894{
895 seq_puts(m, key->description);
896}
897
898/*
899 * grab the security key for a socket
900 */
901int rxrpc_request_key(struct rxrpc_sock *rx, char __user *optval, int optlen)
902{
903 struct key *key;
904 char *description;
905
906 _enter("");
907
908 if (optlen <= 0 || optlen > PAGE_SIZE - 1)
909 return -EINVAL;
910
911 description = memdup_user_nul(optval, optlen);
912 if (IS_ERR(description))
913 return PTR_ERR(description);
914
915 key = request_key(&key_type_rxrpc, description, NULL);
916 if (IS_ERR(key)) {
917 kfree(description);
918 _leave(" = %ld", PTR_ERR(key));
919 return PTR_ERR(key);
920 }
921
922 rx->key = key;
923 kfree(description);
924 _leave(" = 0 [key %x]", key->serial);
925 return 0;
926}
927
928/*
929 * grab the security keyring for a server socket
930 */
931int rxrpc_server_keyring(struct rxrpc_sock *rx, char __user *optval,
932 int optlen)
933{
934 struct key *key;
935 char *description;
936
937 _enter("");
938
939 if (optlen <= 0 || optlen > PAGE_SIZE - 1)
940 return -EINVAL;
941
942 description = memdup_user_nul(optval, optlen);
943 if (IS_ERR(description))
944 return PTR_ERR(description);
945
946 key = request_key(&key_type_keyring, description, NULL);
947 if (IS_ERR(key)) {
948 kfree(description);
949 _leave(" = %ld", PTR_ERR(key));
950 return PTR_ERR(key);
951 }
952
953 rx->securities = key;
954 kfree(description);
955 _leave(" = 0 [key %x]", key->serial);
956 return 0;
957}
958
959/*
960 * generate a server data key
961 */
962int rxrpc_get_server_data_key(struct rxrpc_connection *conn,
963 const void *session_key,
964 time64_t expiry,
965 u32 kvno)
966{
967 const struct cred *cred = current_cred();
968 struct key *key;
969 int ret;
970
971 struct {
972 u32 kver;
973 struct rxrpc_key_data_v1 v1;
974 } data;
975
976 _enter("");
977
978 key = key_alloc(&key_type_rxrpc, "x",
979 GLOBAL_ROOT_UID, GLOBAL_ROOT_GID, cred, 0,
980 KEY_ALLOC_NOT_IN_QUOTA, NULL);
981 if (IS_ERR(key)) {
982 _leave(" = -ENOMEM [alloc %ld]", PTR_ERR(key));
983 return -ENOMEM;
984 }
985
986 _debug("key %d", key_serial(key));
987
988 data.kver = 1;
989 data.v1.security_index = RXRPC_SECURITY_RXKAD;
990 data.v1.ticket_length = 0;
991 data.v1.expiry = rxrpc_time64_to_u32(expiry);
992 data.v1.kvno = 0;
993
994 memcpy(&data.v1.session_key, session_key, sizeof(data.v1.session_key));
995
996 ret = key_instantiate_and_link(key, &data, sizeof(data), NULL, NULL);
997 if (ret < 0)
998 goto error;
999
1000 conn->params.key = key;
1001 _leave(" = 0 [%d]", key_serial(key));
1002 return 0;
1003
1004error:
1005 key_revoke(key);
1006 key_put(key);
1007 _leave(" = -ENOMEM [ins %d]", ret);
1008 return -ENOMEM;
1009}
1010EXPORT_SYMBOL(rxrpc_get_server_data_key);
1011
1012/**
1013 * rxrpc_get_null_key - Generate a null RxRPC key
1014 * @keyname: The name to give the key.
1015 *
1016 * Generate a null RxRPC key that can be used to indicate anonymous security is
1017 * required for a particular domain.
1018 */
1019struct key *rxrpc_get_null_key(const char *keyname)
1020{
1021 const struct cred *cred = current_cred();
1022 struct key *key;
1023 int ret;
1024
1025 key = key_alloc(&key_type_rxrpc, keyname,
1026 GLOBAL_ROOT_UID, GLOBAL_ROOT_GID, cred,
1027 KEY_POS_SEARCH, KEY_ALLOC_NOT_IN_QUOTA, NULL);
1028 if (IS_ERR(key))
1029 return key;
1030
1031 ret = key_instantiate_and_link(key, NULL, 0, NULL, NULL);
1032 if (ret < 0) {
1033 key_revoke(key);
1034 key_put(key);
1035 return ERR_PTR(ret);
1036 }
1037
1038 return key;
1039}
1040EXPORT_SYMBOL(rxrpc_get_null_key);
1041
1042/*
1043 * read the contents of an rxrpc key
1044 * - this returns the result in XDR form
1045 */
1046static long rxrpc_read(const struct key *key,
1047 char __user *buffer, size_t buflen)
1048{
1049 const struct rxrpc_key_token *token;
1050 const struct krb5_principal *princ;
1051 size_t size;
1052 __be32 __user *xdr, *oldxdr;
1053 u32 cnlen, toksize, ntoks, tok, zero;
1054 u16 toksizes[AFSTOKEN_MAX];
1055 int loop;
1056
1057 _enter("");
1058
1059 /* we don't know what form we should return non-AFS keys in */
1060 if (memcmp(key->description, "afs@", 4) != 0)
1061 return -EOPNOTSUPP;
1062 cnlen = strlen(key->description + 4);
1063
1064#define RND(X) (((X) + 3) & ~3)
1065
1066 /* AFS keys we return in XDR form, so we need to work out the size of
1067 * the XDR */
1068 size = 2 * 4; /* flags, cellname len */
1069 size += RND(cnlen); /* cellname */
1070 size += 1 * 4; /* token count */
1071
1072 ntoks = 0;
1073 for (token = key->payload.data[0]; token; token = token->next) {
1074 toksize = 4; /* sec index */
1075
1076 switch (token->security_index) {
1077 case RXRPC_SECURITY_RXKAD:
1078 toksize += 9 * 4; /* viceid, kvno, key*2 + len, begin,
1079 * end, primary, tktlen */
1080 toksize += RND(token->kad->ticket_len);
1081 break;
1082
1083 case RXRPC_SECURITY_RXK5:
1084 princ = &token->k5->client;
1085 toksize += 4 + princ->n_name_parts * 4;
1086 for (loop = 0; loop < princ->n_name_parts; loop++)
1087 toksize += RND(strlen(princ->name_parts[loop]));
1088 toksize += 4 + RND(strlen(princ->realm));
1089
1090 princ = &token->k5->server;
1091 toksize += 4 + princ->n_name_parts * 4;
1092 for (loop = 0; loop < princ->n_name_parts; loop++)
1093 toksize += RND(strlen(princ->name_parts[loop]));
1094 toksize += 4 + RND(strlen(princ->realm));
1095
1096 toksize += 8 + RND(token->k5->session.data_len);
1097
1098 toksize += 4 * 8 + 2 * 4;
1099
1100 toksize += 4 + token->k5->n_addresses * 8;
1101 for (loop = 0; loop < token->k5->n_addresses; loop++)
1102 toksize += RND(token->k5->addresses[loop].data_len);
1103
1104 toksize += 4 + RND(token->k5->ticket_len);
1105 toksize += 4 + RND(token->k5->ticket2_len);
1106
1107 toksize += 4 + token->k5->n_authdata * 8;
1108 for (loop = 0; loop < token->k5->n_authdata; loop++)
1109 toksize += RND(token->k5->authdata[loop].data_len);
1110 break;
1111
1112 default: /* we have a ticket we can't encode */
1113 BUG();
1114 continue;
1115 }
1116
1117 _debug("token[%u]: toksize=%u", ntoks, toksize);
1118 ASSERTCMP(toksize, <=, AFSTOKEN_LENGTH_MAX);
1119
1120 toksizes[ntoks++] = toksize;
1121 size += toksize + 4; /* each token has a length word */
1122 }
1123
1124#undef RND
1125
1126 if (!buffer || buflen < size)
1127 return size;
1128
1129 xdr = (__be32 __user *) buffer;
1130 zero = 0;
1131#define ENCODE(x) \
1132 do { \
1133 __be32 y = htonl(x); \
1134 if (put_user(y, xdr++) < 0) \
1135 goto fault; \
1136 } while(0)
1137#define ENCODE_DATA(l, s) \
1138 do { \
1139 u32 _l = (l); \
1140 ENCODE(l); \
1141 if (copy_to_user(xdr, (s), _l) != 0) \
1142 goto fault; \
1143 if (_l & 3 && \
1144 copy_to_user((u8 __user *)xdr + _l, &zero, 4 - (_l & 3)) != 0) \
1145 goto fault; \
1146 xdr += (_l + 3) >> 2; \
1147 } while(0)
1148#define ENCODE64(x) \
1149 do { \
1150 __be64 y = cpu_to_be64(x); \
1151 if (copy_to_user(xdr, &y, 8) != 0) \
1152 goto fault; \
1153 xdr += 8 >> 2; \
1154 } while(0)
1155#define ENCODE_STR(s) \
1156 do { \
1157 const char *_s = (s); \
1158 ENCODE_DATA(strlen(_s), _s); \
1159 } while(0)
1160
1161 ENCODE(0); /* flags */
1162 ENCODE_DATA(cnlen, key->description + 4); /* cellname */
1163 ENCODE(ntoks);
1164
1165 tok = 0;
1166 for (token = key->payload.data[0]; token; token = token->next) {
1167 toksize = toksizes[tok++];
1168 ENCODE(toksize);
1169 oldxdr = xdr;
1170 ENCODE(token->security_index);
1171
1172 switch (token->security_index) {
1173 case RXRPC_SECURITY_RXKAD:
1174 ENCODE(token->kad->vice_id);
1175 ENCODE(token->kad->kvno);
1176 ENCODE_DATA(8, token->kad->session_key);
1177 ENCODE(token->kad->start);
1178 ENCODE(token->kad->expiry);
1179 ENCODE(token->kad->primary_flag);
1180 ENCODE_DATA(token->kad->ticket_len, token->kad->ticket);
1181 break;
1182
1183 case RXRPC_SECURITY_RXK5:
1184 princ = &token->k5->client;
1185 ENCODE(princ->n_name_parts);
1186 for (loop = 0; loop < princ->n_name_parts; loop++)
1187 ENCODE_STR(princ->name_parts[loop]);
1188 ENCODE_STR(princ->realm);
1189
1190 princ = &token->k5->server;
1191 ENCODE(princ->n_name_parts);
1192 for (loop = 0; loop < princ->n_name_parts; loop++)
1193 ENCODE_STR(princ->name_parts[loop]);
1194 ENCODE_STR(princ->realm);
1195
1196 ENCODE(token->k5->session.tag);
1197 ENCODE_DATA(token->k5->session.data_len,
1198 token->k5->session.data);
1199
1200 ENCODE64(token->k5->authtime);
1201 ENCODE64(token->k5->starttime);
1202 ENCODE64(token->k5->endtime);
1203 ENCODE64(token->k5->renew_till);
1204 ENCODE(token->k5->is_skey);
1205 ENCODE(token->k5->flags);
1206
1207 ENCODE(token->k5->n_addresses);
1208 for (loop = 0; loop < token->k5->n_addresses; loop++) {
1209 ENCODE(token->k5->addresses[loop].tag);
1210 ENCODE_DATA(token->k5->addresses[loop].data_len,
1211 token->k5->addresses[loop].data);
1212 }
1213
1214 ENCODE_DATA(token->k5->ticket_len, token->k5->ticket);
1215 ENCODE_DATA(token->k5->ticket2_len, token->k5->ticket2);
1216
1217 ENCODE(token->k5->n_authdata);
1218 for (loop = 0; loop < token->k5->n_authdata; loop++) {
1219 ENCODE(token->k5->authdata[loop].tag);
1220 ENCODE_DATA(token->k5->authdata[loop].data_len,
1221 token->k5->authdata[loop].data);
1222 }
1223 break;
1224
1225 default:
1226 BUG();
1227 break;
1228 }
1229
1230 ASSERTCMP((unsigned long)xdr - (unsigned long)oldxdr, ==,
1231 toksize);
1232 }
1233
1234#undef ENCODE_STR
1235#undef ENCODE_DATA
1236#undef ENCODE64
1237#undef ENCODE
1238
1239 ASSERTCMP(tok, ==, ntoks);
1240 ASSERTCMP((char __user *) xdr - buffer, ==, size);
1241 _leave(" = %zu", size);
1242 return size;
1243
1244fault:
1245 _leave(" = -EFAULT");
1246 return -EFAULT;
1247}