1 // SPDX-License-Identifier: GPL-2.0-or-later
2 /* RxRPC key management
4 * Copyright (C) 2007 Red Hat, Inc. All Rights Reserved.
5 * Written by David Howells (dhowells@redhat.com)
7 * RxRPC keys should have a description of describing their purpose:
8 * "afs@CAMBRIDGE.REDHAT.COM>
11 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
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>
21 #include <net/af_rxrpc.h>
22 #include <keys/rxrpc-type.h>
23 #include <keys/user-type.h>
24 #include "ar-internal.h"
26 static struct key_acl rxrpc_null_key_acl = {
27 .usage = REFCOUNT_INIT(1),
30 KEY_POSSESSOR_ACE(KEY_ACE_SEARCH | KEY_ACE_READ),
34 static int rxrpc_vet_description_s(const char *);
35 static int rxrpc_preparse(struct key_preparsed_payload *);
36 static int rxrpc_preparse_s(struct key_preparsed_payload *);
37 static void rxrpc_free_preparse(struct key_preparsed_payload *);
38 static void rxrpc_free_preparse_s(struct key_preparsed_payload *);
39 static void rxrpc_destroy(struct key *);
40 static void rxrpc_destroy_s(struct key *);
41 static void rxrpc_describe(const struct key *, struct seq_file *);
42 static long rxrpc_read(const struct key *, char __user *, size_t);
45 * rxrpc defined keys take an arbitrary string as the description and an
46 * arbitrary blob of data as the payload
48 struct key_type key_type_rxrpc = {
50 .flags = KEY_TYPE_NET_DOMAIN,
51 .preparse = rxrpc_preparse,
52 .free_preparse = rxrpc_free_preparse,
53 .instantiate = generic_key_instantiate,
54 .destroy = rxrpc_destroy,
55 .describe = rxrpc_describe,
58 EXPORT_SYMBOL(key_type_rxrpc);
61 * rxrpc server defined keys take "<serviceId>:<securityIndex>" as the
62 * description and an 8-byte decryption key as the payload
64 struct key_type key_type_rxrpc_s = {
66 .flags = KEY_TYPE_NET_DOMAIN,
67 .vet_description = rxrpc_vet_description_s,
68 .preparse = rxrpc_preparse_s,
69 .free_preparse = rxrpc_free_preparse_s,
70 .instantiate = generic_key_instantiate,
71 .destroy = rxrpc_destroy_s,
72 .describe = rxrpc_describe,
76 * Vet the description for an RxRPC server key
78 static int rxrpc_vet_description_s(const char *desc)
83 num = simple_strtoul(desc, &p, 10);
84 if (*p != ':' || num > 65535)
86 num = simple_strtoul(p + 1, &p, 10);
87 if (*p || num < 1 || num > 255)
93 * parse an RxKAD type XDR format token
94 * - the caller guarantees we have at least 4 words
96 static int rxrpc_preparse_xdr_rxkad(struct key_preparsed_payload *prep,
98 const __be32 *xdr, unsigned int toklen)
100 struct rxrpc_key_token *token, **pptoken;
105 _enter(",{%x,%x,%x,%x},%u",
106 ntohl(xdr[0]), ntohl(xdr[1]), ntohl(xdr[2]), ntohl(xdr[3]),
110 return -EKEYREJECTED;
111 tktlen = ntohl(xdr[7]);
112 _debug("tktlen: %x", tktlen);
113 if (tktlen > AFSTOKEN_RK_TIX_MAX)
114 return -EKEYREJECTED;
115 if (toklen < 8 * 4 + tktlen)
116 return -EKEYREJECTED;
118 plen = sizeof(*token) + sizeof(*token->kad) + tktlen;
119 prep->quotalen = datalen + plen;
121 plen -= sizeof(*token);
122 token = kzalloc(sizeof(*token), GFP_KERNEL);
126 token->kad = kzalloc(plen, GFP_KERNEL);
132 token->security_index = RXRPC_SECURITY_RXKAD;
133 token->kad->ticket_len = tktlen;
134 token->kad->vice_id = ntohl(xdr[0]);
135 token->kad->kvno = ntohl(xdr[1]);
136 token->kad->start = ntohl(xdr[4]);
137 token->kad->expiry = ntohl(xdr[5]);
138 token->kad->primary_flag = ntohl(xdr[6]);
139 memcpy(&token->kad->session_key, &xdr[2], 8);
140 memcpy(&token->kad->ticket, &xdr[8], tktlen);
142 _debug("SCIX: %u", token->security_index);
143 _debug("TLEN: %u", token->kad->ticket_len);
144 _debug("EXPY: %x", token->kad->expiry);
145 _debug("KVNO: %u", token->kad->kvno);
146 _debug("PRIM: %u", token->kad->primary_flag);
147 _debug("SKEY: %02x%02x%02x%02x%02x%02x%02x%02x",
148 token->kad->session_key[0], token->kad->session_key[1],
149 token->kad->session_key[2], token->kad->session_key[3],
150 token->kad->session_key[4], token->kad->session_key[5],
151 token->kad->session_key[6], token->kad->session_key[7]);
152 if (token->kad->ticket_len >= 8)
153 _debug("TCKT: %02x%02x%02x%02x%02x%02x%02x%02x",
154 token->kad->ticket[0], token->kad->ticket[1],
155 token->kad->ticket[2], token->kad->ticket[3],
156 token->kad->ticket[4], token->kad->ticket[5],
157 token->kad->ticket[6], token->kad->ticket[7]);
159 /* count the number of tokens attached */
160 prep->payload.data[1] = (void *)((unsigned long)prep->payload.data[1] + 1);
162 /* attach the data */
163 for (pptoken = (struct rxrpc_key_token **)&prep->payload.data[0];
165 pptoken = &(*pptoken)->next)
168 expiry = rxrpc_u32_to_time64(token->kad->expiry);
169 if (expiry < prep->expiry)
170 prep->expiry = expiry;
176 static void rxrpc_free_krb5_principal(struct krb5_principal *princ)
180 if (princ->name_parts) {
181 for (loop = princ->n_name_parts - 1; loop >= 0; loop--)
182 kfree(princ->name_parts[loop]);
183 kfree(princ->name_parts);
188 static void rxrpc_free_krb5_tagged(struct krb5_tagged_data *td)
194 * free up an RxK5 token
196 static void rxrpc_rxk5_free(struct rxk5_key *rxk5)
200 rxrpc_free_krb5_principal(&rxk5->client);
201 rxrpc_free_krb5_principal(&rxk5->server);
202 rxrpc_free_krb5_tagged(&rxk5->session);
204 if (rxk5->addresses) {
205 for (loop = rxk5->n_addresses - 1; loop >= 0; loop--)
206 rxrpc_free_krb5_tagged(&rxk5->addresses[loop]);
207 kfree(rxk5->addresses);
209 if (rxk5->authdata) {
210 for (loop = rxk5->n_authdata - 1; loop >= 0; loop--)
211 rxrpc_free_krb5_tagged(&rxk5->authdata[loop]);
212 kfree(rxk5->authdata);
216 kfree(rxk5->ticket2);
221 * extract a krb5 principal
223 static int rxrpc_krb5_decode_principal(struct krb5_principal *princ,
225 unsigned int *_toklen)
227 const __be32 *xdr = *_xdr;
228 unsigned int toklen = *_toklen, n_parts, loop, tmp, paddedlen;
230 /* there must be at least one name, and at least #names+1 length
235 _enter(",{%x,%x,%x},%u",
236 ntohl(xdr[0]), ntohl(xdr[1]), ntohl(xdr[2]), toklen);
238 n_parts = ntohl(*xdr++);
240 if (n_parts <= 0 || n_parts > AFSTOKEN_K5_COMPONENTS_MAX)
242 princ->n_name_parts = n_parts;
244 if (toklen <= (n_parts + 1) * 4)
247 princ->name_parts = kcalloc(n_parts, sizeof(char *), GFP_KERNEL);
248 if (!princ->name_parts)
251 for (loop = 0; loop < n_parts; loop++) {
256 if (tmp <= 0 || tmp > AFSTOKEN_STRING_MAX)
258 paddedlen = (tmp + 3) & ~3;
259 if (paddedlen > toklen)
261 princ->name_parts[loop] = kmalloc(tmp + 1, GFP_KERNEL);
262 if (!princ->name_parts[loop])
264 memcpy(princ->name_parts[loop], xdr, tmp);
265 princ->name_parts[loop][tmp] = 0;
267 xdr += paddedlen >> 2;
274 if (tmp <= 0 || tmp > AFSTOKEN_K5_REALM_MAX)
276 paddedlen = (tmp + 3) & ~3;
277 if (paddedlen > toklen)
279 princ->realm = kmalloc(tmp + 1, GFP_KERNEL);
282 memcpy(princ->realm, xdr, tmp);
283 princ->realm[tmp] = 0;
285 xdr += paddedlen >> 2;
287 _debug("%s/...@%s", princ->name_parts[0], princ->realm);
291 _leave(" = 0 [toklen=%u]", toklen);
296 * extract a piece of krb5 tagged data
298 static int rxrpc_krb5_decode_tagged_data(struct krb5_tagged_data *td,
299 size_t max_data_size,
301 unsigned int *_toklen)
303 const __be32 *xdr = *_xdr;
304 unsigned int toklen = *_toklen, len, paddedlen;
306 /* there must be at least one tag and one length word */
310 _enter(",%zu,{%x,%x},%u",
311 max_data_size, ntohl(xdr[0]), ntohl(xdr[1]), toklen);
313 td->tag = ntohl(*xdr++);
316 if (len > max_data_size)
318 paddedlen = (len + 3) & ~3;
319 if (paddedlen > toklen)
324 td->data = kmemdup(xdr, len, GFP_KERNEL);
328 xdr += paddedlen >> 2;
331 _debug("tag %x len %x", td->tag, td->data_len);
335 _leave(" = 0 [toklen=%u]", toklen);
340 * extract an array of tagged data
342 static int rxrpc_krb5_decode_tagged_array(struct krb5_tagged_data **_td,
345 size_t max_elem_size,
347 unsigned int *_toklen)
349 struct krb5_tagged_data *td;
350 const __be32 *xdr = *_xdr;
351 unsigned int toklen = *_toklen, n_elem, loop;
354 /* there must be at least one count */
358 _enter(",,%u,%zu,{%x},%u",
359 max_n_elem, max_elem_size, ntohl(xdr[0]), toklen);
361 n_elem = ntohl(*xdr++);
363 if (n_elem > max_n_elem)
367 if (toklen <= (n_elem + 1) * 4)
370 _debug("n_elem %d", n_elem);
372 td = kcalloc(n_elem, sizeof(struct krb5_tagged_data),
378 for (loop = 0; loop < n_elem; loop++) {
379 ret = rxrpc_krb5_decode_tagged_data(&td[loop],
389 _leave(" = 0 [toklen=%u]", toklen);
394 * extract a krb5 ticket
396 static int rxrpc_krb5_decode_ticket(u8 **_ticket, u16 *_tktlen,
397 const __be32 **_xdr, unsigned int *_toklen)
399 const __be32 *xdr = *_xdr;
400 unsigned int toklen = *_toklen, len, paddedlen;
402 /* there must be at least one length word */
406 _enter(",{%x},%u", ntohl(xdr[0]), toklen);
410 if (len > AFSTOKEN_K5_TIX_MAX)
412 paddedlen = (len + 3) & ~3;
413 if (paddedlen > toklen)
417 _debug("ticket len %u", len);
420 *_ticket = kmemdup(xdr, len, GFP_KERNEL);
424 xdr += paddedlen >> 2;
429 _leave(" = 0 [toklen=%u]", toklen);
434 * parse an RxK5 type XDR format token
435 * - the caller guarantees we have at least 4 words
437 static int rxrpc_preparse_xdr_rxk5(struct key_preparsed_payload *prep,
439 const __be32 *xdr, unsigned int toklen)
441 struct rxrpc_key_token *token, **pptoken;
442 struct rxk5_key *rxk5;
443 const __be32 *end_xdr = xdr + (toklen >> 2);
447 _enter(",{%x,%x,%x,%x},%u",
448 ntohl(xdr[0]), ntohl(xdr[1]), ntohl(xdr[2]), ntohl(xdr[3]),
451 /* reserve some payload space for this subkey - the length of the token
452 * is a reasonable approximation */
453 prep->quotalen = datalen + toklen;
455 token = kzalloc(sizeof(*token), GFP_KERNEL);
459 rxk5 = kzalloc(sizeof(*rxk5), GFP_KERNEL);
465 token->security_index = RXRPC_SECURITY_RXK5;
468 /* extract the principals */
469 ret = rxrpc_krb5_decode_principal(&rxk5->client, &xdr, &toklen);
472 ret = rxrpc_krb5_decode_principal(&rxk5->server, &xdr, &toklen);
476 /* extract the session key and the encoding type (the tag field ->
478 ret = rxrpc_krb5_decode_tagged_data(&rxk5->session, AFSTOKEN_DATA_MAX,
483 if (toklen < 4 * 8 + 2 * 4)
485 rxk5->authtime = be64_to_cpup((const __be64 *) xdr);
487 rxk5->starttime = be64_to_cpup((const __be64 *) xdr);
489 rxk5->endtime = be64_to_cpup((const __be64 *) xdr);
491 rxk5->renew_till = be64_to_cpup((const __be64 *) xdr);
493 rxk5->is_skey = ntohl(*xdr++);
494 rxk5->flags = ntohl(*xdr++);
495 toklen -= 4 * 8 + 2 * 4;
497 _debug("times: a=%llx s=%llx e=%llx rt=%llx",
498 rxk5->authtime, rxk5->starttime, rxk5->endtime,
500 _debug("is_skey=%x flags=%x", rxk5->is_skey, rxk5->flags);
502 /* extract the permitted client addresses */
503 ret = rxrpc_krb5_decode_tagged_array(&rxk5->addresses,
505 AFSTOKEN_K5_ADDRESSES_MAX,
511 ASSERTCMP((end_xdr - xdr) << 2, ==, toklen);
513 /* extract the tickets */
514 ret = rxrpc_krb5_decode_ticket(&rxk5->ticket, &rxk5->ticket_len,
518 ret = rxrpc_krb5_decode_ticket(&rxk5->ticket2, &rxk5->ticket2_len,
523 ASSERTCMP((end_xdr - xdr) << 2, ==, toklen);
525 /* extract the typed auth data */
526 ret = rxrpc_krb5_decode_tagged_array(&rxk5->authdata,
528 AFSTOKEN_K5_AUTHDATA_MAX,
529 AFSTOKEN_BDATALN_MAX,
534 ASSERTCMP((end_xdr - xdr) << 2, ==, toklen);
539 /* attach the payload */
540 for (pptoken = (struct rxrpc_key_token **)&prep->payload.data[0];
542 pptoken = &(*pptoken)->next)
545 expiry = rxrpc_u32_to_time64(token->k5->endtime);
546 if (expiry < prep->expiry)
547 prep->expiry = expiry;
555 rxrpc_rxk5_free(rxk5);
557 _leave(" = %d", ret);
562 * attempt to parse the data as the XDR format
563 * - the caller guarantees we have more than 7 words
565 static int rxrpc_preparse_xdr(struct key_preparsed_payload *prep)
567 const __be32 *xdr = prep->data, *token;
569 unsigned int len, paddedlen, loop, ntoken, toklen, sec_ix;
570 size_t datalen = prep->datalen;
573 _enter(",{%x,%x,%x,%x},%zu",
574 ntohl(xdr[0]), ntohl(xdr[1]), ntohl(xdr[2]), ntohl(xdr[3]),
577 if (datalen > AFSTOKEN_LENGTH_MAX)
580 /* XDR is an array of __be32's */
584 /* the flags should be 0 (the setpag bit must be handled by
586 if (ntohl(*xdr++) != 0)
590 /* check the cell name */
592 if (len < 1 || len > AFSTOKEN_CELL_MAX)
595 paddedlen = (len + 3) & ~3;
596 if (paddedlen > datalen)
599 cp = (const char *) xdr;
600 for (loop = 0; loop < len; loop++)
601 if (!isprint(cp[loop]))
603 for (; loop < paddedlen; loop++)
606 _debug("cellname: [%u/%u] '%*.*s'",
607 len, paddedlen, len, len, (const char *) xdr);
608 datalen -= paddedlen;
609 xdr += paddedlen >> 2;
611 /* get the token count */
614 ntoken = ntohl(*xdr++);
616 _debug("ntoken: %x", ntoken);
617 if (ntoken < 1 || ntoken > AFSTOKEN_MAX)
620 /* check each token wrapper */
626 toklen = ntohl(*xdr++);
627 sec_ix = ntohl(*xdr);
629 _debug("token: [%x/%zx] %x", toklen, datalen, sec_ix);
630 paddedlen = (toklen + 3) & ~3;
631 if (toklen < 20 || toklen > datalen || paddedlen > datalen)
633 datalen -= paddedlen;
634 xdr += paddedlen >> 2;
636 } while (--loop > 0);
638 _debug("remainder: %zu", datalen);
642 /* okay: we're going to assume it's valid XDR format
643 * - we ignore the cellname, relying on the key to be correctly named
647 toklen = ntohl(*xdr++);
648 token = xdr + ((toklen + 3) >> 2);
649 sec_ix = ntohl(*xdr++);
652 _debug("TOKEN type=%u [%p-%p]", sec_ix, xdr, token);
655 case RXRPC_SECURITY_RXKAD:
656 ret = rxrpc_preparse_xdr_rxkad(prep, datalen, xdr, toklen);
661 case RXRPC_SECURITY_RXK5:
662 ret = rxrpc_preparse_xdr_rxk5(prep, datalen, xdr, toklen);
668 ret = -EPROTONOSUPPORT;
672 } while (--ntoken > 0);
678 _leave(" = -EPROTO");
681 _leave(" = %d", ret);
686 * Preparse an rxrpc defined key.
688 * Data should be of the form:
690 * 0 4 key interface version number
691 * 4 2 security index (type)
693 * 8 4 key expiry time (time_t)
698 * if no data is provided, then a no-security key is made
700 static int rxrpc_preparse(struct key_preparsed_payload *prep)
702 const struct rxrpc_key_data_v1 *v1;
703 struct rxrpc_key_token *token, **pp;
709 _enter("%zu", prep->datalen);
711 /* handle a no-security key */
712 if (!prep->data && prep->datalen == 0)
715 /* determine if the XDR payload format is being used */
716 if (prep->datalen > 7 * 4) {
717 ret = rxrpc_preparse_xdr(prep);
722 /* get the key interface version number */
724 if (prep->datalen <= 4 || !prep->data)
726 memcpy(&kver, prep->data, sizeof(kver));
727 prep->data += sizeof(kver);
728 prep->datalen -= sizeof(kver);
730 _debug("KEY I/F VERSION: %u", kver);
736 /* deal with a version 1 key */
738 if (prep->datalen < sizeof(*v1))
742 if (prep->datalen != sizeof(*v1) + v1->ticket_length)
745 _debug("SCIX: %u", v1->security_index);
746 _debug("TLEN: %u", v1->ticket_length);
747 _debug("EXPY: %x", v1->expiry);
748 _debug("KVNO: %u", v1->kvno);
749 _debug("SKEY: %02x%02x%02x%02x%02x%02x%02x%02x",
750 v1->session_key[0], v1->session_key[1],
751 v1->session_key[2], v1->session_key[3],
752 v1->session_key[4], v1->session_key[5],
753 v1->session_key[6], v1->session_key[7]);
754 if (v1->ticket_length >= 8)
755 _debug("TCKT: %02x%02x%02x%02x%02x%02x%02x%02x",
756 v1->ticket[0], v1->ticket[1],
757 v1->ticket[2], v1->ticket[3],
758 v1->ticket[4], v1->ticket[5],
759 v1->ticket[6], v1->ticket[7]);
761 ret = -EPROTONOSUPPORT;
762 if (v1->security_index != RXRPC_SECURITY_RXKAD)
765 plen = sizeof(*token->kad) + v1->ticket_length;
766 prep->quotalen = plen + sizeof(*token);
769 token = kzalloc(sizeof(*token), GFP_KERNEL);
772 token->kad = kzalloc(plen, GFP_KERNEL);
776 token->security_index = RXRPC_SECURITY_RXKAD;
777 token->kad->ticket_len = v1->ticket_length;
778 token->kad->expiry = v1->expiry;
779 token->kad->kvno = v1->kvno;
780 memcpy(&token->kad->session_key, &v1->session_key, 8);
781 memcpy(&token->kad->ticket, v1->ticket, v1->ticket_length);
783 /* count the number of tokens attached */
784 prep->payload.data[1] = (void *)((unsigned long)prep->payload.data[1] + 1);
786 /* attach the data */
787 pp = (struct rxrpc_key_token **)&prep->payload.data[0];
791 expiry = rxrpc_u32_to_time64(token->kad->expiry);
792 if (expiry < prep->expiry)
793 prep->expiry = expiry;
806 static void rxrpc_free_token_list(struct rxrpc_key_token *token)
808 struct rxrpc_key_token *next;
810 for (; token; token = next) {
812 switch (token->security_index) {
813 case RXRPC_SECURITY_RXKAD:
816 case RXRPC_SECURITY_RXK5:
818 rxrpc_rxk5_free(token->k5);
821 pr_err("Unknown token type %x on rxrpc key\n",
822 token->security_index);
831 * Clean up preparse data.
833 static void rxrpc_free_preparse(struct key_preparsed_payload *prep)
835 rxrpc_free_token_list(prep->payload.data[0]);
839 * Preparse a server secret key.
841 * The data should be the 8-byte secret key.
843 static int rxrpc_preparse_s(struct key_preparsed_payload *prep)
845 struct crypto_skcipher *ci;
847 _enter("%zu", prep->datalen);
849 if (prep->datalen != 8)
852 memcpy(&prep->payload.data[2], prep->data, 8);
854 ci = crypto_alloc_skcipher("pcbc(des)", 0, CRYPTO_ALG_ASYNC);
856 _leave(" = %ld", PTR_ERR(ci));
860 if (crypto_skcipher_setkey(ci, prep->data, 8) < 0)
863 prep->payload.data[0] = ci;
869 * Clean up preparse data.
871 static void rxrpc_free_preparse_s(struct key_preparsed_payload *prep)
873 if (prep->payload.data[0])
874 crypto_free_skcipher(prep->payload.data[0]);
878 * dispose of the data dangling from the corpse of a rxrpc key
880 static void rxrpc_destroy(struct key *key)
882 rxrpc_free_token_list(key->payload.data[0]);
886 * dispose of the data dangling from the corpse of a rxrpc key
888 static void rxrpc_destroy_s(struct key *key)
890 if (key->payload.data[0]) {
891 crypto_free_skcipher(key->payload.data[0]);
892 key->payload.data[0] = NULL;
897 * describe the rxrpc key
899 static void rxrpc_describe(const struct key *key, struct seq_file *m)
901 seq_puts(m, key->description);
905 * grab the security key for a socket
907 int rxrpc_request_key(struct rxrpc_sock *rx, char __user *optval, int optlen)
914 if (optlen <= 0 || optlen > PAGE_SIZE - 1)
917 description = memdup_user_nul(optval, optlen);
918 if (IS_ERR(description))
919 return PTR_ERR(description);
921 key = request_key_net(&key_type_rxrpc, description, sock_net(&rx->sk),
925 _leave(" = %ld", PTR_ERR(key));
931 _leave(" = 0 [key %x]", key->serial);
936 * grab the security keyring for a server socket
938 int rxrpc_server_keyring(struct rxrpc_sock *rx, char __user *optval,
946 if (optlen <= 0 || optlen > PAGE_SIZE - 1)
949 description = memdup_user_nul(optval, optlen);
950 if (IS_ERR(description))
951 return PTR_ERR(description);
953 key = request_key_net(&key_type_keyring, description, sock_net(&rx->sk),
957 _leave(" = %ld", PTR_ERR(key));
961 rx->securities = key;
963 _leave(" = 0 [key %x]", key->serial);
968 * generate a server data key
970 int rxrpc_get_server_data_key(struct rxrpc_connection *conn,
971 const void *session_key,
975 const struct cred *cred = current_cred();
981 struct rxrpc_key_data_v1 v1;
986 key = key_alloc(&key_type_rxrpc, "x",
987 GLOBAL_ROOT_UID, GLOBAL_ROOT_GID, cred,
989 KEY_ALLOC_NOT_IN_QUOTA, NULL);
991 _leave(" = -ENOMEM [alloc %ld]", PTR_ERR(key));
995 _debug("key %d", key_serial(key));
998 data.v1.security_index = RXRPC_SECURITY_RXKAD;
999 data.v1.ticket_length = 0;
1000 data.v1.expiry = rxrpc_time64_to_u32(expiry);
1003 memcpy(&data.v1.session_key, session_key, sizeof(data.v1.session_key));
1005 ret = key_instantiate_and_link(key, &data, sizeof(data), NULL, NULL);
1009 conn->params.key = key;
1010 _leave(" = 0 [%d]", key_serial(key));
1016 _leave(" = -ENOMEM [ins %d]", ret);
1019 EXPORT_SYMBOL(rxrpc_get_server_data_key);
1022 * rxrpc_get_null_key - Generate a null RxRPC key
1023 * @keyname: The name to give the key.
1025 * Generate a null RxRPC key that can be used to indicate anonymous security is
1026 * required for a particular domain.
1028 struct key *rxrpc_get_null_key(const char *keyname)
1030 const struct cred *cred = current_cred();
1034 key = key_alloc(&key_type_rxrpc, keyname,
1035 GLOBAL_ROOT_UID, GLOBAL_ROOT_GID, cred,
1036 &rxrpc_null_key_acl, KEY_ALLOC_NOT_IN_QUOTA, NULL);
1040 ret = key_instantiate_and_link(key, NULL, 0, NULL, NULL);
1044 return ERR_PTR(ret);
1049 EXPORT_SYMBOL(rxrpc_get_null_key);
1052 * read the contents of an rxrpc key
1053 * - this returns the result in XDR form
1055 static long rxrpc_read(const struct key *key,
1056 char __user *buffer, size_t buflen)
1058 const struct rxrpc_key_token *token;
1059 const struct krb5_principal *princ;
1061 __be32 __user *xdr, *oldxdr;
1062 u32 cnlen, toksize, ntoks, tok, zero;
1063 u16 toksizes[AFSTOKEN_MAX];
1068 /* we don't know what form we should return non-AFS keys in */
1069 if (memcmp(key->description, "afs@", 4) != 0)
1071 cnlen = strlen(key->description + 4);
1073 #define RND(X) (((X) + 3) & ~3)
1075 /* AFS keys we return in XDR form, so we need to work out the size of
1077 size = 2 * 4; /* flags, cellname len */
1078 size += RND(cnlen); /* cellname */
1079 size += 1 * 4; /* token count */
1082 for (token = key->payload.data[0]; token; token = token->next) {
1083 toksize = 4; /* sec index */
1085 switch (token->security_index) {
1086 case RXRPC_SECURITY_RXKAD:
1087 toksize += 9 * 4; /* viceid, kvno, key*2 + len, begin,
1088 * end, primary, tktlen */
1089 toksize += RND(token->kad->ticket_len);
1092 case RXRPC_SECURITY_RXK5:
1093 princ = &token->k5->client;
1094 toksize += 4 + princ->n_name_parts * 4;
1095 for (loop = 0; loop < princ->n_name_parts; loop++)
1096 toksize += RND(strlen(princ->name_parts[loop]));
1097 toksize += 4 + RND(strlen(princ->realm));
1099 princ = &token->k5->server;
1100 toksize += 4 + princ->n_name_parts * 4;
1101 for (loop = 0; loop < princ->n_name_parts; loop++)
1102 toksize += RND(strlen(princ->name_parts[loop]));
1103 toksize += 4 + RND(strlen(princ->realm));
1105 toksize += 8 + RND(token->k5->session.data_len);
1107 toksize += 4 * 8 + 2 * 4;
1109 toksize += 4 + token->k5->n_addresses * 8;
1110 for (loop = 0; loop < token->k5->n_addresses; loop++)
1111 toksize += RND(token->k5->addresses[loop].data_len);
1113 toksize += 4 + RND(token->k5->ticket_len);
1114 toksize += 4 + RND(token->k5->ticket2_len);
1116 toksize += 4 + token->k5->n_authdata * 8;
1117 for (loop = 0; loop < token->k5->n_authdata; loop++)
1118 toksize += RND(token->k5->authdata[loop].data_len);
1121 default: /* we have a ticket we can't encode */
1126 _debug("token[%u]: toksize=%u", ntoks, toksize);
1127 ASSERTCMP(toksize, <=, AFSTOKEN_LENGTH_MAX);
1129 toksizes[ntoks++] = toksize;
1130 size += toksize + 4; /* each token has a length word */
1135 if (!buffer || buflen < size)
1138 xdr = (__be32 __user *) buffer;
1142 __be32 y = htonl(x); \
1143 if (put_user(y, xdr++) < 0) \
1146 #define ENCODE_DATA(l, s) \
1150 if (copy_to_user(xdr, (s), _l) != 0) \
1153 copy_to_user((u8 __user *)xdr + _l, &zero, 4 - (_l & 3)) != 0) \
1155 xdr += (_l + 3) >> 2; \
1157 #define ENCODE64(x) \
1159 __be64 y = cpu_to_be64(x); \
1160 if (copy_to_user(xdr, &y, 8) != 0) \
1164 #define ENCODE_STR(s) \
1166 const char *_s = (s); \
1167 ENCODE_DATA(strlen(_s), _s); \
1170 ENCODE(0); /* flags */
1171 ENCODE_DATA(cnlen, key->description + 4); /* cellname */
1175 for (token = key->payload.data[0]; token; token = token->next) {
1176 toksize = toksizes[tok++];
1179 ENCODE(token->security_index);
1181 switch (token->security_index) {
1182 case RXRPC_SECURITY_RXKAD:
1183 ENCODE(token->kad->vice_id);
1184 ENCODE(token->kad->kvno);
1185 ENCODE_DATA(8, token->kad->session_key);
1186 ENCODE(token->kad->start);
1187 ENCODE(token->kad->expiry);
1188 ENCODE(token->kad->primary_flag);
1189 ENCODE_DATA(token->kad->ticket_len, token->kad->ticket);
1192 case RXRPC_SECURITY_RXK5:
1193 princ = &token->k5->client;
1194 ENCODE(princ->n_name_parts);
1195 for (loop = 0; loop < princ->n_name_parts; loop++)
1196 ENCODE_STR(princ->name_parts[loop]);
1197 ENCODE_STR(princ->realm);
1199 princ = &token->k5->server;
1200 ENCODE(princ->n_name_parts);
1201 for (loop = 0; loop < princ->n_name_parts; loop++)
1202 ENCODE_STR(princ->name_parts[loop]);
1203 ENCODE_STR(princ->realm);
1205 ENCODE(token->k5->session.tag);
1206 ENCODE_DATA(token->k5->session.data_len,
1207 token->k5->session.data);
1209 ENCODE64(token->k5->authtime);
1210 ENCODE64(token->k5->starttime);
1211 ENCODE64(token->k5->endtime);
1212 ENCODE64(token->k5->renew_till);
1213 ENCODE(token->k5->is_skey);
1214 ENCODE(token->k5->flags);
1216 ENCODE(token->k5->n_addresses);
1217 for (loop = 0; loop < token->k5->n_addresses; loop++) {
1218 ENCODE(token->k5->addresses[loop].tag);
1219 ENCODE_DATA(token->k5->addresses[loop].data_len,
1220 token->k5->addresses[loop].data);
1223 ENCODE_DATA(token->k5->ticket_len, token->k5->ticket);
1224 ENCODE_DATA(token->k5->ticket2_len, token->k5->ticket2);
1226 ENCODE(token->k5->n_authdata);
1227 for (loop = 0; loop < token->k5->n_authdata; loop++) {
1228 ENCODE(token->k5->authdata[loop].tag);
1229 ENCODE_DATA(token->k5->authdata[loop].data_len,
1230 token->k5->authdata[loop].data);
1239 ASSERTCMP((unsigned long)xdr - (unsigned long)oldxdr, ==,
1248 ASSERTCMP(tok, ==, ntoks);
1249 ASSERTCMP((char __user *) xdr - buffer, ==, size);
1250 _leave(" = %zu", size);
1254 _leave(" = -EFAULT");