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