net/rxrpc/ar-key.c

   1 /* RxRPC key management
   2  *
   3  * Copyright (C) 2007 Red Hat, Inc. All Rights Reserved.
   4  * Written by David Howells (dhowells@redhat.com)
   5  *
   6  * This program is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU General Public License
   8  * as published by the Free Software Foundation; either version
   9  * 2 of the License, or (at your option) any later version.
  10  *
  11  * RxRPC keys should have a description of describing their purpose:
  12  *      "afs@CAMBRIDGE.REDHAT.COM>
  13  */
  14
  15 #include <linux/module.h>
  16 #include <linux/net.h>
  17 #include <linux/skbuff.h>
  18 #include <linux/key-type.h>
  19 #include <linux/crypto.h>
  20 #include <linux/ctype.h>
  21 #include <linux/slab.h>
  22 #include <net/sock.h>
  23 #include <net/af_rxrpc.h>
  24 #include <keys/rxrpc-type.h>
  25 #include <keys/user-type.h>
  26 #include "ar-internal.h"
  27
  28 static int rxrpc_vet_description_s(const char *);
  29 static int rxrpc_preparse(struct key_preparsed_payload *);
  30 static int rxrpc_preparse_s(struct key_preparsed_payload *);
  31 static void rxrpc_free_preparse(struct key_preparsed_payload *);
  32 static void rxrpc_free_preparse_s(struct key_preparsed_payload *);
  33 static void rxrpc_destroy(struct key *);
  34 static void rxrpc_destroy_s(struct key *);
  35 static void rxrpc_describe(const struct key *, struct seq_file *);
  36 static long rxrpc_read(const struct key *, char __user *, size_t);
  37
  38 /*
  39  * rxrpc defined keys take an arbitrary string as the description and an
  40  * arbitrary blob of data as the payload
  41  */
  42 struct key_type key_type_rxrpc = {
  43         .name           = "rxrpc",
  44         .preparse       = rxrpc_preparse,
  45         .free_preparse  = rxrpc_free_preparse,
  46         .instantiate    = generic_key_instantiate,
  47         .match          = user_match,
  48         .destroy        = rxrpc_destroy,
  49         .describe       = rxrpc_describe,
  50         .read           = rxrpc_read,
  51 };
  52 EXPORT_SYMBOL(key_type_rxrpc);
  53
  54 /*
  55  * rxrpc server defined keys take "<serviceId>:<securityIndex>" as the
  56  * description and an 8-byte decryption key as the payload
  57  */
  58 struct key_type key_type_rxrpc_s = {
  59         .name           = "rxrpc_s",
  60         .vet_description = rxrpc_vet_description_s,
  61         .preparse       = rxrpc_preparse_s,
  62         .free_preparse  = rxrpc_free_preparse_s,
  63         .instantiate    = generic_key_instantiate,
  64         .match          = user_match,
  65         .destroy        = rxrpc_destroy_s,
  66         .describe       = rxrpc_describe,
  67 };
  68
  69 /*
  70  * Vet the description for an RxRPC server key
  71  */
  72 static 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  */
  90 static 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         size_t plen;
  96         u32 tktlen;
  97
  98         _enter(",{%x,%x,%x,%x},%u",
  99                ntohl(xdr[0]), ntohl(xdr[1]), ntohl(xdr[2]), ntohl(xdr[3]),
 100                toklen);
 101
 102         if (toklen <= 8 * 4)
 103                 return -EKEYREJECTED;
 104         tktlen = ntohl(xdr[7]);
 105         _debug("tktlen: %x", tktlen);
 106         if (tktlen > AFSTOKEN_RK_TIX_MAX)
 107                 return -EKEYREJECTED;
 108         if (toklen < 8 * 4 + tktlen)
 109                 return -EKEYREJECTED;
 110
 111         plen = sizeof(*token) + sizeof(*token->kad) + tktlen;
 112         prep->quotalen = datalen + plen;
 113
 114         plen -= sizeof(*token);
 115         token = kzalloc(sizeof(*token), GFP_KERNEL);
 116         if (!token)
 117                 return -ENOMEM;
 118
 119         token->kad = kzalloc(plen, GFP_KERNEL);
 120         if (!token->kad) {
 121                 kfree(token);
 122                 return -ENOMEM;
 123         }
 124
 125         token->security_index   = RXRPC_SECURITY_RXKAD;
 126         token->kad->ticket_len  = tktlen;
 127         token->kad->vice_id     = ntohl(xdr[0]);
 128         token->kad->kvno        = ntohl(xdr[1]);
 129         token->kad->start       = ntohl(xdr[4]);
 130         token->kad->expiry      = ntohl(xdr[5]);
 131         token->kad->primary_flag = ntohl(xdr[6]);
 132         memcpy(&token->kad->session_key, &xdr[2], 8);
 133         memcpy(&token->kad->ticket, &xdr[8], tktlen);
 134
 135         _debug("SCIX: %u", token->security_index);
 136         _debug("TLEN: %u", token->kad->ticket_len);
 137         _debug("EXPY: %x", token->kad->expiry);
 138         _debug("KVNO: %u", token->kad->kvno);
 139         _debug("PRIM: %u", token->kad->primary_flag);
 140         _debug("SKEY: %02x%02x%02x%02x%02x%02x%02x%02x",
 141                token->kad->session_key[0], token->kad->session_key[1],
 142                token->kad->session_key[2], token->kad->session_key[3],
 143                token->kad->session_key[4], token->kad->session_key[5],
 144                token->kad->session_key[6], token->kad->session_key[7]);
 145         if (token->kad->ticket_len >= 8)
 146                 _debug("TCKT: %02x%02x%02x%02x%02x%02x%02x%02x",
 147                        token->kad->ticket[0], token->kad->ticket[1],
 148                        token->kad->ticket[2], token->kad->ticket[3],
 149                        token->kad->ticket[4], token->kad->ticket[5],
 150                        token->kad->ticket[6], token->kad->ticket[7]);
 151
 152         /* count the number of tokens attached */
 153         prep->type_data[0] = (void *)((unsigned long)prep->type_data[0] + 1);
 154
 155         /* attach the data */
 156         for (pptoken = (struct rxrpc_key_token **)&prep->payload[0];
 157              *pptoken;
 158              pptoken = &(*pptoken)->next)
 159                 continue;
 160         *pptoken = token;
 161         if (token->kad->expiry < prep->expiry)
 162                 prep->expiry = token->kad->expiry;
 163
 164         _leave(" = 0");
 165         return 0;
 166 }
 167
 168 static void rxrpc_free_krb5_principal(struct krb5_principal *princ)
 169 {
 170         int loop;
 171
 172         if (princ->name_parts) {
 173                 for (loop = princ->n_name_parts - 1; loop >= 0; loop--)
 174                         kfree(princ->name_parts[loop]);
 175                 kfree(princ->name_parts);
 176         }
 177         kfree(princ->realm);
 178 }
 179
 180 static void rxrpc_free_krb5_tagged(struct krb5_tagged_data *td)
 181 {
 182         kfree(td->data);
 183 }
 184
 185 /*
 186  * free up an RxK5 token
 187  */
 188 static void rxrpc_rxk5_free(struct rxk5_key *rxk5)
 189 {
 190         int loop;
 191
 192         rxrpc_free_krb5_principal(&rxk5->client);
 193         rxrpc_free_krb5_principal(&rxk5->server);
 194         rxrpc_free_krb5_tagged(&rxk5->session);
 195
 196         if (rxk5->addresses) {
 197                 for (loop = rxk5->n_addresses - 1; loop >= 0; loop--)
 198                         rxrpc_free_krb5_tagged(&rxk5->addresses[loop]);
 199                 kfree(rxk5->addresses);
 200         }
 201         if (rxk5->authdata) {
 202                 for (loop = rxk5->n_authdata - 1; loop >= 0; loop--)
 203                         rxrpc_free_krb5_tagged(&rxk5->authdata[loop]);
 204                 kfree(rxk5->authdata);
 205         }
 206
 207         kfree(rxk5->ticket);
 208         kfree(rxk5->ticket2);
 209         kfree(rxk5);
 210 }
 211
 212 /*
 213  * extract a krb5 principal
 214  */
 215 static int rxrpc_krb5_decode_principal(struct krb5_principal *princ,
 216                                        const __be32 **_xdr,
 217                                        unsigned int *_toklen)
 218 {
 219         const __be32 *xdr = *_xdr;
 220         unsigned int toklen = *_toklen, n_parts, loop, tmp;
 221
 222         /* there must be at least one name, and at least #names+1 length
 223          * words */
 224         if (toklen <= 12)
 225                 return -EINVAL;
 226
 227         _enter(",{%x,%x,%x},%u",
 228                ntohl(xdr[0]), ntohl(xdr[1]), ntohl(xdr[2]), toklen);
 229
 230         n_parts = ntohl(*xdr++);
 231         toklen -= 4;
 232         if (n_parts <= 0 || n_parts > AFSTOKEN_K5_COMPONENTS_MAX)
 233                 return -EINVAL;
 234         princ->n_name_parts = n_parts;
 235
 236         if (toklen <= (n_parts + 1) * 4)
 237                 return -EINVAL;
 238
 239         princ->name_parts = kcalloc(n_parts, sizeof(char *), GFP_KERNEL);
 240         if (!princ->name_parts)
 241                 return -ENOMEM;
 242
 243         for (loop = 0; loop < n_parts; loop++) {
 244                 if (toklen < 4)
 245                         return -EINVAL;
 246                 tmp = ntohl(*xdr++);
 247                 toklen -= 4;
 248                 if (tmp <= 0 || tmp > AFSTOKEN_STRING_MAX)
 249                         return -EINVAL;
 250                 if (tmp > toklen)
 251                         return -EINVAL;
 252                 princ->name_parts[loop] = kmalloc(tmp + 1, GFP_KERNEL);
 253                 if (!princ->name_parts[loop])
 254                         return -ENOMEM;
 255                 memcpy(princ->name_parts[loop], xdr, tmp);
 256                 princ->name_parts[loop][tmp] = 0;
 257                 tmp = (tmp + 3) & ~3;
 258                 toklen -= tmp;
 259                 xdr += tmp >> 2;
 260         }
 261
 262         if (toklen < 4)
 263                 return -EINVAL;
 264         tmp = ntohl(*xdr++);
 265         toklen -= 4;
 266         if (tmp <= 0 || tmp > AFSTOKEN_K5_REALM_MAX)
 267                 return -EINVAL;
 268         if (tmp > toklen)
 269                 return -EINVAL;
 270         princ->realm = kmalloc(tmp + 1, GFP_KERNEL);
 271         if (!princ->realm)
 272                 return -ENOMEM;
 273         memcpy(princ->realm, xdr, tmp);
 274         princ->realm[tmp] = 0;
 275         tmp = (tmp + 3) & ~3;
 276         toklen -= tmp;
 277         xdr += tmp >> 2;
 278
 279         _debug("%s/...@%s", princ->name_parts[0], princ->realm);
 280
 281         *_xdr = xdr;
 282         *_toklen = toklen;
 283         _leave(" = 0 [toklen=%u]", toklen);
 284         return 0;
 285 }
 286
 287 /*
 288  * extract a piece of krb5 tagged data
 289  */
 290 static int rxrpc_krb5_decode_tagged_data(struct krb5_tagged_data *td,
 291                                          size_t max_data_size,
 292                                          const __be32 **_xdr,
 293                                          unsigned int *_toklen)
 294 {
 295         const __be32 *xdr = *_xdr;
 296         unsigned int toklen = *_toklen, len;
 297
 298         /* there must be at least one tag and one length word */
 299         if (toklen <= 8)
 300                 return -EINVAL;
 301
 302         _enter(",%zu,{%x,%x},%u",
 303                max_data_size, ntohl(xdr[0]), ntohl(xdr[1]), toklen);
 304
 305         td->tag = ntohl(*xdr++);
 306         len = ntohl(*xdr++);
 307         toklen -= 8;
 308         if (len > max_data_size)
 309                 return -EINVAL;
 310         td->data_len = len;
 311
 312         if (len > 0) {
 313                 td->data = kmemdup(xdr, len, GFP_KERNEL);
 314                 if (!td->data)
 315                         return -ENOMEM;
 316                 len = (len + 3) & ~3;
 317                 toklen -= len;
 318                 xdr += len >> 2;
 319         }
 320
 321         _debug("tag %x len %x", td->tag, td->data_len);
 322
 323         *_xdr = xdr;
 324         *_toklen = toklen;
 325         _leave(" = 0 [toklen=%u]", toklen);
 326         return 0;
 327 }
 328
 329 /*
 330  * extract an array of tagged data
 331  */
 332 static int rxrpc_krb5_decode_tagged_array(struct krb5_tagged_data **_td,
 333                                           u8 *_n_elem,
 334                                           u8 max_n_elem,
 335                                           size_t max_elem_size,
 336                                           const __be32 **_xdr,
 337                                           unsigned int *_toklen)
 338 {
 339         struct krb5_tagged_data *td;
 340         const __be32 *xdr = *_xdr;
 341         unsigned int toklen = *_toklen, n_elem, loop;
 342         int ret;
 343
 344         /* there must be at least one count */
 345         if (toklen < 4)
 346                 return -EINVAL;
 347
 348         _enter(",,%u,%zu,{%x},%u",
 349                max_n_elem, max_elem_size, ntohl(xdr[0]), toklen);
 350
 351         n_elem = ntohl(*xdr++);
 352         toklen -= 4;
 353         if (n_elem > max_n_elem)
 354                 return -EINVAL;
 355         *_n_elem = n_elem;
 356         if (n_elem > 0) {
 357                 if (toklen <= (n_elem + 1) * 4)
 358                         return -EINVAL;
 359
 360                 _debug("n_elem %d", n_elem);
 361
 362                 td = kcalloc(n_elem, sizeof(struct krb5_tagged_data),
 363                              GFP_KERNEL);
 364                 if (!td)
 365                         return -ENOMEM;
 366                 *_td = td;
 367
 368                 for (loop = 0; loop < n_elem; loop++) {
 369                         ret = rxrpc_krb5_decode_tagged_data(&td[loop],
 370                                                             max_elem_size,
 371                                                             &xdr, &toklen);
 372                         if (ret < 0)
 373                                 return ret;
 374                 }
 375         }
 376
 377         *_xdr = xdr;
 378         *_toklen = toklen;
 379         _leave(" = 0 [toklen=%u]", toklen);
 380         return 0;
 381 }
 382
 383 /*
 384  * extract a krb5 ticket
 385  */
 386 static int rxrpc_krb5_decode_ticket(u8 **_ticket, u16 *_tktlen,
 387                                     const __be32 **_xdr, unsigned int *_toklen)
 388 {
 389         const __be32 *xdr = *_xdr;
 390         unsigned int toklen = *_toklen, len;
 391
 392         /* there must be at least one length word */
 393         if (toklen <= 4)
 394                 return -EINVAL;
 395
 396         _enter(",{%x},%u", ntohl(xdr[0]), toklen);
 397
 398         len = ntohl(*xdr++);
 399         toklen -= 4;
 400         if (len > AFSTOKEN_K5_TIX_MAX)
 401                 return -EINVAL;
 402         *_tktlen = len;
 403
 404         _debug("ticket len %u", len);
 405
 406         if (len > 0) {
 407                 *_ticket = kmemdup(xdr, len, GFP_KERNEL);
 408                 if (!*_ticket)
 409                         return -ENOMEM;
 410                 len = (len + 3) & ~3;
 411                 toklen -= len;
 412                 xdr += len >> 2;
 413         }
 414
 415         *_xdr = xdr;
 416         *_toklen = toklen;
 417         _leave(" = 0 [toklen=%u]", toklen);
 418         return 0;
 419 }
 420
 421 /*
 422  * parse an RxK5 type XDR format token
 423  * - the caller guarantees we have at least 4 words
 424  */
 425 static int rxrpc_preparse_xdr_rxk5(struct key_preparsed_payload *prep,
 426                                    size_t datalen,
 427                                    const __be32 *xdr, unsigned int toklen)
 428 {
 429         struct rxrpc_key_token *token, **pptoken;
 430         struct rxk5_key *rxk5;
 431         const __be32 *end_xdr = xdr + (toklen >> 2);
 432         int ret;
 433
 434         _enter(",{%x,%x,%x,%x},%u",
 435                ntohl(xdr[0]), ntohl(xdr[1]), ntohl(xdr[2]), ntohl(xdr[3]),
 436                toklen);
 437
 438         /* reserve some payload space for this subkey - the length of the token
 439          * is a reasonable approximation */
 440         prep->quotalen = datalen + toklen;
 441
 442         token = kzalloc(sizeof(*token), GFP_KERNEL);
 443         if (!token)
 444                 return -ENOMEM;
 445
 446         rxk5 = kzalloc(sizeof(*rxk5), GFP_KERNEL);
 447         if (!rxk5) {
 448                 kfree(token);
 449                 return -ENOMEM;
 450         }
 451
 452         token->security_index = RXRPC_SECURITY_RXK5;
 453         token->k5 = rxk5;
 454
 455         /* extract the principals */
 456         ret = rxrpc_krb5_decode_principal(&rxk5->client, &xdr, &toklen);
 457         if (ret < 0)
 458                 goto error;
 459         ret = rxrpc_krb5_decode_principal(&rxk5->server, &xdr, &toklen);
 460         if (ret < 0)
 461                 goto error;
 462
 463         /* extract the session key and the encoding type (the tag field ->
 464          * ENCTYPE_xxx) */
 465         ret = rxrpc_krb5_decode_tagged_data(&rxk5->session, AFSTOKEN_DATA_MAX,
 466                                             &xdr, &toklen);
 467         if (ret < 0)
 468                 goto error;
 469
 470         if (toklen < 4 * 8 + 2 * 4)
 471                 goto inval;
 472         rxk5->authtime  = be64_to_cpup((const __be64 *) xdr);
 473         xdr += 2;
 474         rxk5->starttime = be64_to_cpup((const __be64 *) xdr);
 475         xdr += 2;
 476         rxk5->endtime   = be64_to_cpup((const __be64 *) xdr);
 477         xdr += 2;
 478         rxk5->renew_till = be64_to_cpup((const __be64 *) xdr);
 479         xdr += 2;
 480         rxk5->is_skey = ntohl(*xdr++);
 481         rxk5->flags = ntohl(*xdr++);
 482         toklen -= 4 * 8 + 2 * 4;
 483
 484         _debug("times: a=%llx s=%llx e=%llx rt=%llx",
 485                rxk5->authtime, rxk5->starttime, rxk5->endtime,
 486                rxk5->renew_till);
 487         _debug("is_skey=%x flags=%x", rxk5->is_skey, rxk5->flags);
 488
 489         /* extract the permitted client addresses */
 490         ret = rxrpc_krb5_decode_tagged_array(&rxk5->addresses,
 491                                              &rxk5->n_addresses,
 492                                              AFSTOKEN_K5_ADDRESSES_MAX,
 493                                              AFSTOKEN_DATA_MAX,
 494                                              &xdr, &toklen);
 495         if (ret < 0)
 496                 goto error;
 497
 498         ASSERTCMP((end_xdr - xdr) << 2, ==, toklen);
 499
 500         /* extract the tickets */
 501         ret = rxrpc_krb5_decode_ticket(&rxk5->ticket, &rxk5->ticket_len,
 502                                        &xdr, &toklen);
 503         if (ret < 0)
 504                 goto error;
 505         ret = rxrpc_krb5_decode_ticket(&rxk5->ticket2, &rxk5->ticket2_len,
 506                                        &xdr, &toklen);
 507         if (ret < 0)
 508                 goto error;
 509
 510         ASSERTCMP((end_xdr - xdr) << 2, ==, toklen);
 511
 512         /* extract the typed auth data */
 513         ret = rxrpc_krb5_decode_tagged_array(&rxk5->authdata,
 514                                              &rxk5->n_authdata,
 515                                              AFSTOKEN_K5_AUTHDATA_MAX,
 516                                              AFSTOKEN_BDATALN_MAX,
 517                                              &xdr, &toklen);
 518         if (ret < 0)
 519                 goto error;
 520
 521         ASSERTCMP((end_xdr - xdr) << 2, ==, toklen);
 522
 523         if (toklen != 0)
 524                 goto inval;
 525
 526         /* attach the payload */
 527         for (pptoken = (struct rxrpc_key_token **)&prep->payload[0];
 528              *pptoken;
 529              pptoken = &(*pptoken)->next)
 530                 continue;
 531         *pptoken = token;
 532         if (token->kad->expiry < prep->expiry)
 533                 prep->expiry = token->kad->expiry;
 534
 535         _leave(" = 0");
 536         return 0;
 537
 538 inval:
 539         ret = -EINVAL;
 540 error:
 541         rxrpc_rxk5_free(rxk5);
 542         kfree(token);
 543         _leave(" = %d", ret);
 544         return ret;
 545 }
 546
 547 /*
 548  * attempt to parse the data as the XDR format
 549  * - the caller guarantees we have more than 7 words
 550  */
 551 static int rxrpc_preparse_xdr(struct key_preparsed_payload *prep)
 552 {
 553         const __be32 *xdr = prep->data, *token;
 554         const char *cp;
 555         unsigned int len, tmp, loop, ntoken, toklen, sec_ix;
 556         size_t datalen = prep->datalen;
 557         int ret;
 558
 559         _enter(",{%x,%x,%x,%x},%zu",
 560                ntohl(xdr[0]), ntohl(xdr[1]), ntohl(xdr[2]), ntohl(xdr[3]),
 561                prep->datalen);
 562
 563         if (datalen > AFSTOKEN_LENGTH_MAX)
 564                 goto not_xdr;
 565
 566         /* XDR is an array of __be32's */
 567         if (datalen & 3)
 568                 goto not_xdr;
 569
 570         /* the flags should be 0 (the setpag bit must be handled by
 571          * userspace) */
 572         if (ntohl(*xdr++) != 0)
 573                 goto not_xdr;
 574         datalen -= 4;
 575
 576         /* check the cell name */
 577         len = ntohl(*xdr++);
 578         if (len < 1 || len > AFSTOKEN_CELL_MAX)
 579                 goto not_xdr;
 580         datalen -= 4;
 581         tmp = (len + 3) & ~3;
 582         if (tmp > datalen)
 583                 goto not_xdr;
 584
 585         cp = (const char *) xdr;
 586         for (loop = 0; loop < len; loop++)
 587                 if (!isprint(cp[loop]))
 588                         goto not_xdr;
 589         if (len < tmp)
 590                 for (; loop < tmp; loop++)
 591                         if (cp[loop])
 592                                 goto not_xdr;
 593         _debug("cellname: [%u/%u] '%*.*s'",
 594                len, tmp, len, len, (const char *) xdr);
 595         datalen -= tmp;
 596         xdr += tmp >> 2;
 597
 598         /* get the token count */
 599         if (datalen < 12)
 600                 goto not_xdr;
 601         ntoken = ntohl(*xdr++);
 602         datalen -= 4;
 603         _debug("ntoken: %x", ntoken);
 604         if (ntoken < 1 || ntoken > AFSTOKEN_MAX)
 605                 goto not_xdr;
 606
 607         /* check each token wrapper */
 608         token = xdr;
 609         loop = ntoken;
 610         do {
 611                 if (datalen < 8)
 612                         goto not_xdr;
 613                 toklen = ntohl(*xdr++);
 614                 sec_ix = ntohl(*xdr);
 615                 datalen -= 4;
 616                 _debug("token: [%x/%zx] %x", toklen, datalen, sec_ix);
 617                 if (toklen < 20 || toklen > datalen)
 618                         goto not_xdr;
 619                 datalen -= (toklen + 3) & ~3;
 620                 xdr += (toklen + 3) >> 2;
 621
 622         } while (--loop > 0);
 623
 624         _debug("remainder: %zu", datalen);
 625         if (datalen != 0)
 626                 goto not_xdr;
 627
 628         /* okay: we're going to assume it's valid XDR format
 629          * - we ignore the cellname, relying on the key to be correctly named
 630          */
 631         do {
 632                 xdr = token;
 633                 toklen = ntohl(*xdr++);
 634                 token = xdr + ((toklen + 3) >> 2);
 635                 sec_ix = ntohl(*xdr++);
 636                 toklen -= 4;
 637
 638                 _debug("TOKEN type=%u [%p-%p]", sec_ix, xdr, token);
 639
 640                 switch (sec_ix) {
 641                 case RXRPC_SECURITY_RXKAD:
 642                         ret = rxrpc_preparse_xdr_rxkad(prep, datalen, xdr, toklen);
 643                         if (ret != 0)
 644                                 goto error;
 645                         break;
 646
 647                 case RXRPC_SECURITY_RXK5:
 648                         ret = rxrpc_preparse_xdr_rxk5(prep, datalen, xdr, toklen);
 649                         if (ret != 0)
 650                                 goto error;
 651                         break;
 652
 653                 default:
 654                         ret = -EPROTONOSUPPORT;
 655                         goto error;
 656                 }
 657
 658         } while (--ntoken > 0);
 659
 660         _leave(" = 0");
 661         return 0;
 662
 663 not_xdr:
 664         _leave(" = -EPROTO");
 665         return -EPROTO;
 666 error:
 667         _leave(" = %d", ret);
 668         return ret;
 669 }
 670
 671 /*
 672  * Preparse an rxrpc defined key.
 673  *
 674  * Data should be of the form:
 675  *      OFFSET  LEN     CONTENT
 676  *      0       4       key interface version number
 677  *      4       2       security index (type)
 678  *      6       2       ticket length
 679  *      8       4       key expiry time (time_t)
 680  *      12      4       kvno
 681  *      16      8       session key
 682  *      24      [len]   ticket
 683  *
 684  * if no data is provided, then a no-security key is made
 685  */
 686 static int rxrpc_preparse(struct key_preparsed_payload *prep)
 687 {
 688         const struct rxrpc_key_data_v1 *v1;
 689         struct rxrpc_key_token *token, **pp;
 690         size_t plen;
 691         u32 kver;
 692         int ret;
 693
 694         _enter("%zu", prep->datalen);
 695
 696         /* handle a no-security key */
 697         if (!prep->data && prep->datalen == 0)
 698                 return 0;
 699
 700         /* determine if the XDR payload format is being used */
 701         if (prep->datalen > 7 * 4) {
 702                 ret = rxrpc_preparse_xdr(prep);
 703                 if (ret != -EPROTO)
 704                         return ret;
 705         }
 706
 707         /* get the key interface version number */
 708         ret = -EINVAL;
 709         if (prep->datalen <= 4 || !prep->data)
 710                 goto error;
 711         memcpy(&kver, prep->data, sizeof(kver));
 712         prep->data += sizeof(kver);
 713         prep->datalen -= sizeof(kver);
 714
 715         _debug("KEY I/F VERSION: %u", kver);
 716
 717         ret = -EKEYREJECTED;
 718         if (kver != 1)
 719                 goto error;
 720
 721         /* deal with a version 1 key */
 722         ret = -EINVAL;
 723         if (prep->datalen < sizeof(*v1))
 724                 goto error;
 725
 726         v1 = prep->data;
 727         if (prep->datalen != sizeof(*v1) + v1->ticket_length)
 728                 goto error;
 729
 730         _debug("SCIX: %u", v1->security_index);
 731         _debug("TLEN: %u", v1->ticket_length);
 732         _debug("EXPY: %x", v1->expiry);
 733         _debug("KVNO: %u", v1->kvno);
 734         _debug("SKEY: %02x%02x%02x%02x%02x%02x%02x%02x",
 735                v1->session_key[0], v1->session_key[1],
 736                v1->session_key[2], v1->session_key[3],
 737                v1->session_key[4], v1->session_key[5],
 738                v1->session_key[6], v1->session_key[7]);
 739         if (v1->ticket_length >= 8)
 740                 _debug("TCKT: %02x%02x%02x%02x%02x%02x%02x%02x",
 741                        v1->ticket[0], v1->ticket[1],
 742                        v1->ticket[2], v1->ticket[3],
 743                        v1->ticket[4], v1->ticket[5],
 744                        v1->ticket[6], v1->ticket[7]);
 745
 746         ret = -EPROTONOSUPPORT;
 747         if (v1->security_index != RXRPC_SECURITY_RXKAD)
 748                 goto error;
 749
 750         plen = sizeof(*token->kad) + v1->ticket_length;
 751         prep->quotalen = plen + sizeof(*token);
 752
 753         ret = -ENOMEM;
 754         token = kzalloc(sizeof(*token), GFP_KERNEL);
 755         if (!token)
 756                 goto error;
 757         token->kad = kzalloc(plen, GFP_KERNEL);
 758         if (!token->kad)
 759                 goto error_free;
 760
 761         token->security_index           = RXRPC_SECURITY_RXKAD;
 762         token->kad->ticket_len          = v1->ticket_length;
 763         token->kad->expiry              = v1->expiry;
 764         token->kad->kvno                = v1->kvno;
 765         memcpy(&token->kad->session_key, &v1->session_key, 8);
 766         memcpy(&token->kad->ticket, v1->ticket, v1->ticket_length);
 767
 768         /* count the number of tokens attached */
 769         prep->type_data[0] = (void *)((unsigned long)prep->type_data[0] + 1);
 770
 771         /* attach the data */
 772         pp = (struct rxrpc_key_token **)&prep->payload[0];
 773         while (*pp)
 774                 pp = &(*pp)->next;
 775         *pp = token;
 776         if (token->kad->expiry < prep->expiry)
 777                 prep->expiry = token->kad->expiry;
 778         token = NULL;
 779         ret = 0;
 780
 781 error_free:
 782         kfree(token);
 783 error:
 784         return ret;
 785 }
 786
 787 /*
 788  * Free token list.
 789  */
 790 static void rxrpc_free_token_list(struct rxrpc_key_token *token)
 791 {
 792         struct rxrpc_key_token *next;
 793
 794         for (; token; token = next) {
 795                 next = token->next;
 796                 switch (token->security_index) {
 797                 case RXRPC_SECURITY_RXKAD:
 798                         kfree(token->kad);
 799                         break;
 800                 case RXRPC_SECURITY_RXK5:
 801                         if (token->k5)
 802                                 rxrpc_rxk5_free(token->k5);
 803                         break;
 804                 default:
 805                         printk(KERN_ERR "Unknown token type %x on rxrpc key\n",
 806                                token->security_index);
 807                         BUG();
 808                 }
 809
 810                 kfree(token);
 811         }
 812 }
 813
 814 /*
 815  * Clean up preparse data.
 816  */
 817 static void rxrpc_free_preparse(struct key_preparsed_payload *prep)
 818 {
 819         rxrpc_free_token_list(prep->payload[0]);
 820 }
 821
 822 /*
 823  * Preparse a server secret key.
 824  *
 825  * The data should be the 8-byte secret key.
 826  */
 827 static int rxrpc_preparse_s(struct key_preparsed_payload *prep)
 828 {
 829         struct crypto_blkcipher *ci;
 830
 831         _enter("%zu", prep->datalen);
 832
 833         if (prep->datalen != 8)
 834                 return -EINVAL;
 835
 836         memcpy(&prep->type_data, prep->data, 8);
 837
 838         ci = crypto_alloc_blkcipher("pcbc(des)", 0, CRYPTO_ALG_ASYNC);
 839         if (IS_ERR(ci)) {
 840                 _leave(" = %ld", PTR_ERR(ci));
 841                 return PTR_ERR(ci);
 842         }
 843
 844         if (crypto_blkcipher_setkey(ci, prep->data, 8) < 0)
 845                 BUG();
 846
 847         prep->payload[0] = ci;
 848         _leave(" = 0");
 849         return 0;
 850 }
 851
 852 /*
 853  * Clean up preparse data.
 854  */
 855 static void rxrpc_free_preparse_s(struct key_preparsed_payload *prep)
 856 {
 857         if (prep->payload[0])
 858                 crypto_free_blkcipher(prep->payload[0]);
 859 }
 860
 861 /*
 862  * dispose of the data dangling from the corpse of a rxrpc key
 863  */
 864 static void rxrpc_destroy(struct key *key)
 865 {
 866         rxrpc_free_token_list(key->payload.data);
 867 }
 868
 869 /*
 870  * dispose of the data dangling from the corpse of a rxrpc key
 871  */
 872 static void rxrpc_destroy_s(struct key *key)
 873 {
 874         if (key->payload.data) {
 875                 crypto_free_blkcipher(key->payload.data);
 876                 key->payload.data = NULL;
 877         }
 878 }
 879
 880 /*
 881  * describe the rxrpc key
 882  */
 883 static void rxrpc_describe(const struct key *key, struct seq_file *m)
 884 {
 885         seq_puts(m, key->description);
 886 }
 887
 888 /*
 889  * grab the security key for a socket
 890  */
 891 int rxrpc_request_key(struct rxrpc_sock *rx, char __user *optval, int optlen)
 892 {
 893         struct key *key;
 894         char *description;
 895
 896         _enter("");
 897
 898         if (optlen <= 0 || optlen > PAGE_SIZE - 1)
 899                 return -EINVAL;
 900
 901         description = kmalloc(optlen + 1, GFP_KERNEL);
 902         if (!description)
 903                 return -ENOMEM;
 904
 905         if (copy_from_user(description, optval, optlen)) {
 906                 kfree(description);
 907                 return -EFAULT;
 908         }
 909         description[optlen] = 0;
 910
 911         key = request_key(&key_type_rxrpc, description, NULL);
 912         if (IS_ERR(key)) {
 913                 kfree(description);
 914                 _leave(" = %ld", PTR_ERR(key));
 915                 return PTR_ERR(key);
 916         }
 917
 918         rx->key = key;
 919         kfree(description);
 920         _leave(" = 0 [key %x]", key->serial);
 921         return 0;
 922 }
 923
 924 /*
 925  * grab the security keyring for a server socket
 926  */
 927 int rxrpc_server_keyring(struct rxrpc_sock *rx, char __user *optval,
 928                          int optlen)
 929 {
 930         struct key *key;
 931         char *description;
 932
 933         _enter("");
 934
 935         if (optlen <= 0 || optlen > PAGE_SIZE - 1)
 936                 return -EINVAL;
 937
 938         description = kmalloc(optlen + 1, GFP_KERNEL);
 939         if (!description)
 940                 return -ENOMEM;
 941
 942         if (copy_from_user(description, optval, optlen)) {
 943                 kfree(description);
 944                 return -EFAULT;
 945         }
 946         description[optlen] = 0;
 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                               time_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);
 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 = 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->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);
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; token; token = token->next) {
1076                 toksize = 4;    /* sec index */
1077
1078                 switch (token->security_index) {
1079                 case RXRPC_SECURITY_RXKAD:
1080                         toksize += 8 * 4;       /* viceid, kvno, key*2, 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 *)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; 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 }