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