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