net/rxrpc/key.c

   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@example.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
  26 static int rxrpc_preparse(struct key_preparsed_payload *);
  27 static void rxrpc_free_preparse(struct key_preparsed_payload *);
  28 static void rxrpc_destroy(struct key *);
  29 static void rxrpc_describe(const struct key *, struct seq_file *);
  30 static long rxrpc_read(const struct key *, char *, size_t);
  31
  32 /*
  33  * rxrpc defined keys take an arbitrary string as the description and an
  34  * arbitrary blob of data as the payload
  35  */
  36 struct key_type key_type_rxrpc = {
  37         .name           = "rxrpc",
  38         .flags          = KEY_TYPE_NET_DOMAIN,
  39         .preparse       = rxrpc_preparse,
  40         .free_preparse  = rxrpc_free_preparse,
  41         .instantiate    = generic_key_instantiate,
  42         .destroy        = rxrpc_destroy,
  43         .describe       = rxrpc_describe,
  44         .read           = rxrpc_read,
  45 };
  46 EXPORT_SYMBOL(key_type_rxrpc);
  47
  48 /*
  49  * parse an RxKAD type XDR format token
  50  * - the caller guarantees we have at least 4 words
  51  */
  52 static int rxrpc_preparse_xdr_rxkad(struct key_preparsed_payload *prep,
  53                                     size_t datalen,
  54                                     const __be32 *xdr, unsigned int toklen)
  55 {
  56         struct rxrpc_key_token *token, **pptoken;
  57         time64_t expiry;
  58         size_t plen;
  59         u32 tktlen;
  60
  61         _enter(",{%x,%x,%x,%x},%u",
  62                ntohl(xdr[0]), ntohl(xdr[1]), ntohl(xdr[2]), ntohl(xdr[3]),
  63                toklen);
  64
  65         if (toklen <= 8 * 4)
  66                 return -EKEYREJECTED;
  67         tktlen = ntohl(xdr[7]);
  68         _debug("tktlen: %x", tktlen);
  69         if (tktlen > AFSTOKEN_RK_TIX_MAX)
  70                 return -EKEYREJECTED;
  71         if (toklen < 8 * 4 + tktlen)
  72                 return -EKEYREJECTED;
  73
  74         plen = sizeof(*token) + sizeof(*token->kad) + tktlen;
  75         prep->quotalen = datalen + plen;
  76
  77         plen -= sizeof(*token);
  78         token = kzalloc(sizeof(*token), GFP_KERNEL);
  79         if (!token)
  80                 return -ENOMEM;
  81
  82         token->kad = kzalloc(plen, GFP_KERNEL);
  83         if (!token->kad) {
  84                 kfree(token);
  85                 return -ENOMEM;
  86         }
  87
  88         token->security_index   = RXRPC_SECURITY_RXKAD;
  89         token->kad->ticket_len  = tktlen;
  90         token->kad->vice_id     = ntohl(xdr[0]);
  91         token->kad->kvno        = ntohl(xdr[1]);
  92         token->kad->start       = ntohl(xdr[4]);
  93         token->kad->expiry      = ntohl(xdr[5]);
  94         token->kad->primary_flag = ntohl(xdr[6]);
  95         memcpy(&token->kad->session_key, &xdr[2], 8);
  96         memcpy(&token->kad->ticket, &xdr[8], tktlen);
  97
  98         _debug("SCIX: %u", token->security_index);
  99         _debug("TLEN: %u", token->kad->ticket_len);
 100         _debug("EXPY: %x", token->kad->expiry);
 101         _debug("KVNO: %u", token->kad->kvno);
 102         _debug("PRIM: %u", token->kad->primary_flag);
 103         _debug("SKEY: %02x%02x%02x%02x%02x%02x%02x%02x",
 104                token->kad->session_key[0], token->kad->session_key[1],
 105                token->kad->session_key[2], token->kad->session_key[3],
 106                token->kad->session_key[4], token->kad->session_key[5],
 107                token->kad->session_key[6], token->kad->session_key[7]);
 108         if (token->kad->ticket_len >= 8)
 109                 _debug("TCKT: %02x%02x%02x%02x%02x%02x%02x%02x",
 110                        token->kad->ticket[0], token->kad->ticket[1],
 111                        token->kad->ticket[2], token->kad->ticket[3],
 112                        token->kad->ticket[4], token->kad->ticket[5],
 113                        token->kad->ticket[6], token->kad->ticket[7]);
 114
 115         /* count the number of tokens attached */
 116         prep->payload.data[1] = (void *)((unsigned long)prep->payload.data[1] + 1);
 117
 118         /* attach the data */
 119         for (pptoken = (struct rxrpc_key_token **)&prep->payload.data[0];
 120              *pptoken;
 121              pptoken = &(*pptoken)->next)
 122                 continue;
 123         *pptoken = token;
 124         expiry = rxrpc_u32_to_time64(token->kad->expiry);
 125         if (expiry < prep->expiry)
 126                 prep->expiry = expiry;
 127
 128         _leave(" = 0");
 129         return 0;
 130 }
 131
 132 /*
 133  * attempt to parse the data as the XDR format
 134  * - the caller guarantees we have more than 7 words
 135  */
 136 static int rxrpc_preparse_xdr(struct key_preparsed_payload *prep)
 137 {
 138         const __be32 *xdr = prep->data, *token, *p;
 139         const char *cp;
 140         unsigned int len, paddedlen, loop, ntoken, toklen, sec_ix;
 141         size_t datalen = prep->datalen;
 142         int ret, ret2;
 143
 144         _enter(",{%x,%x,%x,%x},%zu",
 145                ntohl(xdr[0]), ntohl(xdr[1]), ntohl(xdr[2]), ntohl(xdr[3]),
 146                prep->datalen);
 147
 148         if (datalen > AFSTOKEN_LENGTH_MAX)
 149                 goto not_xdr;
 150
 151         /* XDR is an array of __be32's */
 152         if (datalen & 3)
 153                 goto not_xdr;
 154
 155         /* the flags should be 0 (the setpag bit must be handled by
 156          * userspace) */
 157         if (ntohl(*xdr++) != 0)
 158                 goto not_xdr;
 159         datalen -= 4;
 160
 161         /* check the cell name */
 162         len = ntohl(*xdr++);
 163         if (len < 1 || len > AFSTOKEN_CELL_MAX)
 164                 goto not_xdr;
 165         datalen -= 4;
 166         paddedlen = (len + 3) & ~3;
 167         if (paddedlen > datalen)
 168                 goto not_xdr;
 169
 170         cp = (const char *) xdr;
 171         for (loop = 0; loop < len; loop++)
 172                 if (!isprint(cp[loop]))
 173                         goto not_xdr;
 174         for (; loop < paddedlen; loop++)
 175                 if (cp[loop])
 176                         goto not_xdr;
 177         _debug("cellname: [%u/%u] '%*.*s'",
 178                len, paddedlen, len, len, (const char *) xdr);
 179         datalen -= paddedlen;
 180         xdr += paddedlen >> 2;
 181
 182         /* get the token count */
 183         if (datalen < 12)
 184                 goto not_xdr;
 185         ntoken = ntohl(*xdr++);
 186         datalen -= 4;
 187         _debug("ntoken: %x", ntoken);
 188         if (ntoken < 1 || ntoken > AFSTOKEN_MAX)
 189                 goto not_xdr;
 190
 191         /* check each token wrapper */
 192         p = xdr;
 193         loop = ntoken;
 194         do {
 195                 if (datalen < 8)
 196                         goto not_xdr;
 197                 toklen = ntohl(*p++);
 198                 sec_ix = ntohl(*p);
 199                 datalen -= 4;
 200                 _debug("token: [%x/%zx] %x", toklen, datalen, sec_ix);
 201                 paddedlen = (toklen + 3) & ~3;
 202                 if (toklen < 20 || toklen > datalen || paddedlen > datalen)
 203                         goto not_xdr;
 204                 datalen -= paddedlen;
 205                 p += paddedlen >> 2;
 206
 207         } while (--loop > 0);
 208
 209         _debug("remainder: %zu", datalen);
 210         if (datalen != 0)
 211                 goto not_xdr;
 212
 213         /* okay: we're going to assume it's valid XDR format
 214          * - we ignore the cellname, relying on the key to be correctly named
 215          */
 216         ret = -EPROTONOSUPPORT;
 217         do {
 218                 toklen = ntohl(*xdr++);
 219                 token = xdr;
 220                 xdr += (toklen + 3) / 4;
 221
 222                 sec_ix = ntohl(*token++);
 223                 toklen -= 4;
 224
 225                 _debug("TOKEN type=%x len=%x", sec_ix, toklen);
 226
 227                 switch (sec_ix) {
 228                 case RXRPC_SECURITY_RXKAD:
 229                         ret2 = rxrpc_preparse_xdr_rxkad(prep, datalen, token, toklen);
 230                         break;
 231                 default:
 232                         ret2 = -EPROTONOSUPPORT;
 233                         break;
 234                 }
 235
 236                 switch (ret2) {
 237                 case 0:
 238                         ret = 0;
 239                         break;
 240                 case -EPROTONOSUPPORT:
 241                         break;
 242                 case -ENOPKG:
 243                         if (ret != 0)
 244                                 ret = -ENOPKG;
 245                         break;
 246                 default:
 247                         ret = ret2;
 248                         goto error;
 249                 }
 250
 251         } while (--ntoken > 0);
 252
 253 error:
 254         _leave(" = %d", ret);
 255         return ret;
 256
 257 not_xdr:
 258         _leave(" = -EPROTO");
 259         return -EPROTO;
 260 }
 261
 262 /*
 263  * Preparse an rxrpc defined key.
 264  *
 265  * Data should be of the form:
 266  *      OFFSET  LEN     CONTENT
 267  *      0       4       key interface version number
 268  *      4       2       security index (type)
 269  *      6       2       ticket length
 270  *      8       4       key expiry time (time_t)
 271  *      12      4       kvno
 272  *      16      8       session key
 273  *      24      [len]   ticket
 274  *
 275  * if no data is provided, then a no-security key is made
 276  */
 277 static int rxrpc_preparse(struct key_preparsed_payload *prep)
 278 {
 279         const struct rxrpc_key_data_v1 *v1;
 280         struct rxrpc_key_token *token, **pp;
 281         time64_t expiry;
 282         size_t plen;
 283         u32 kver;
 284         int ret;
 285
 286         _enter("%zu", prep->datalen);
 287
 288         /* handle a no-security key */
 289         if (!prep->data && prep->datalen == 0)
 290                 return 0;
 291
 292         /* determine if the XDR payload format is being used */
 293         if (prep->datalen > 7 * 4) {
 294                 ret = rxrpc_preparse_xdr(prep);
 295                 if (ret != -EPROTO)
 296                         return ret;
 297         }
 298
 299         /* get the key interface version number */
 300         ret = -EINVAL;
 301         if (prep->datalen <= 4 || !prep->data)
 302                 goto error;
 303         memcpy(&kver, prep->data, sizeof(kver));
 304         prep->data += sizeof(kver);
 305         prep->datalen -= sizeof(kver);
 306
 307         _debug("KEY I/F VERSION: %u", kver);
 308
 309         ret = -EKEYREJECTED;
 310         if (kver != 1)
 311                 goto error;
 312
 313         /* deal with a version 1 key */
 314         ret = -EINVAL;
 315         if (prep->datalen < sizeof(*v1))
 316                 goto error;
 317
 318         v1 = prep->data;
 319         if (prep->datalen != sizeof(*v1) + v1->ticket_length)
 320                 goto error;
 321
 322         _debug("SCIX: %u", v1->security_index);
 323         _debug("TLEN: %u", v1->ticket_length);
 324         _debug("EXPY: %x", v1->expiry);
 325         _debug("KVNO: %u", v1->kvno);
 326         _debug("SKEY: %02x%02x%02x%02x%02x%02x%02x%02x",
 327                v1->session_key[0], v1->session_key[1],
 328                v1->session_key[2], v1->session_key[3],
 329                v1->session_key[4], v1->session_key[5],
 330                v1->session_key[6], v1->session_key[7]);
 331         if (v1->ticket_length >= 8)
 332                 _debug("TCKT: %02x%02x%02x%02x%02x%02x%02x%02x",
 333                        v1->ticket[0], v1->ticket[1],
 334                        v1->ticket[2], v1->ticket[3],
 335                        v1->ticket[4], v1->ticket[5],
 336                        v1->ticket[6], v1->ticket[7]);
 337
 338         ret = -EPROTONOSUPPORT;
 339         if (v1->security_index != RXRPC_SECURITY_RXKAD)
 340                 goto error;
 341
 342         plen = sizeof(*token->kad) + v1->ticket_length;
 343         prep->quotalen = plen + sizeof(*token);
 344
 345         ret = -ENOMEM;
 346         token = kzalloc(sizeof(*token), GFP_KERNEL);
 347         if (!token)
 348                 goto error;
 349         token->kad = kzalloc(plen, GFP_KERNEL);
 350         if (!token->kad)
 351                 goto error_free;
 352
 353         token->security_index           = RXRPC_SECURITY_RXKAD;
 354         token->kad->ticket_len          = v1->ticket_length;
 355         token->kad->expiry              = v1->expiry;
 356         token->kad->kvno                = v1->kvno;
 357         memcpy(&token->kad->session_key, &v1->session_key, 8);
 358         memcpy(&token->kad->ticket, v1->ticket, v1->ticket_length);
 359
 360         /* count the number of tokens attached */
 361         prep->payload.data[1] = (void *)((unsigned long)prep->payload.data[1] + 1);
 362
 363         /* attach the data */
 364         pp = (struct rxrpc_key_token **)&prep->payload.data[0];
 365         while (*pp)
 366                 pp = &(*pp)->next;
 367         *pp = token;
 368         expiry = rxrpc_u32_to_time64(token->kad->expiry);
 369         if (expiry < prep->expiry)
 370                 prep->expiry = expiry;
 371         token = NULL;
 372         ret = 0;
 373
 374 error_free:
 375         kfree(token);
 376 error:
 377         return ret;
 378 }
 379
 380 /*
 381  * Free token list.
 382  */
 383 static void rxrpc_free_token_list(struct rxrpc_key_token *token)
 384 {
 385         struct rxrpc_key_token *next;
 386
 387         for (; token; token = next) {
 388                 next = token->next;
 389                 switch (token->security_index) {
 390                 case RXRPC_SECURITY_RXKAD:
 391                         kfree(token->kad);
 392                         break;
 393                 default:
 394                         pr_err("Unknown token type %x on rxrpc key\n",
 395                                token->security_index);
 396                         BUG();
 397                 }
 398
 399                 kfree(token);
 400         }
 401 }
 402
 403 /*
 404  * Clean up preparse data.
 405  */
 406 static void rxrpc_free_preparse(struct key_preparsed_payload *prep)
 407 {
 408         rxrpc_free_token_list(prep->payload.data[0]);
 409 }
 410
 411 /*
 412  * dispose of the data dangling from the corpse of a rxrpc key
 413  */
 414 static void rxrpc_destroy(struct key *key)
 415 {
 416         rxrpc_free_token_list(key->payload.data[0]);
 417 }
 418
 419 /*
 420  * describe the rxrpc key
 421  */
 422 static void rxrpc_describe(const struct key *key, struct seq_file *m)
 423 {
 424         const struct rxrpc_key_token *token;
 425         const char *sep = ": ";
 426
 427         seq_puts(m, key->description);
 428
 429         for (token = key->payload.data[0]; token; token = token->next) {
 430                 seq_puts(m, sep);
 431
 432                 switch (token->security_index) {
 433                 case RXRPC_SECURITY_RXKAD:
 434                         seq_puts(m, "ka");
 435                         break;
 436                 default: /* we have a ticket we can't encode */
 437                         seq_printf(m, "%u", token->security_index);
 438                         break;
 439                 }
 440
 441                 sep = " ";
 442         }
 443 }
 444
 445 /*
 446  * grab the security key for a socket
 447  */
 448 int rxrpc_request_key(struct rxrpc_sock *rx, sockptr_t optval, int optlen)
 449 {
 450         struct key *key;
 451         char *description;
 452
 453         _enter("");
 454
 455         if (optlen <= 0 || optlen > PAGE_SIZE - 1 || rx->securities)
 456                 return -EINVAL;
 457
 458         description = memdup_sockptr_nul(optval, optlen);
 459         if (IS_ERR(description))
 460                 return PTR_ERR(description);
 461
 462         key = request_key_net(&key_type_rxrpc, description, sock_net(&rx->sk), NULL);
 463         if (IS_ERR(key)) {
 464                 kfree(description);
 465                 _leave(" = %ld", PTR_ERR(key));
 466                 return PTR_ERR(key);
 467         }
 468
 469         rx->key = key;
 470         kfree(description);
 471         _leave(" = 0 [key %x]", key->serial);
 472         return 0;
 473 }
 474
 475 /*
 476  * generate a server data key
 477  */
 478 int rxrpc_get_server_data_key(struct rxrpc_connection *conn,
 479                               const void *session_key,
 480                               time64_t expiry,
 481                               u32 kvno)
 482 {
 483         const struct cred *cred = current_cred();
 484         struct key *key;
 485         int ret;
 486
 487         struct {
 488                 u32 kver;
 489                 struct rxrpc_key_data_v1 v1;
 490         } data;
 491
 492         _enter("");
 493
 494         key = key_alloc(&key_type_rxrpc, "x",
 495                         GLOBAL_ROOT_UID, GLOBAL_ROOT_GID, cred, 0,
 496                         KEY_ALLOC_NOT_IN_QUOTA, NULL);
 497         if (IS_ERR(key)) {
 498                 _leave(" = -ENOMEM [alloc %ld]", PTR_ERR(key));
 499                 return -ENOMEM;
 500         }
 501
 502         _debug("key %d", key_serial(key));
 503
 504         data.kver = 1;
 505         data.v1.security_index = RXRPC_SECURITY_RXKAD;
 506         data.v1.ticket_length = 0;
 507         data.v1.expiry = rxrpc_time64_to_u32(expiry);
 508         data.v1.kvno = 0;
 509
 510         memcpy(&data.v1.session_key, session_key, sizeof(data.v1.session_key));
 511
 512         ret = key_instantiate_and_link(key, &data, sizeof(data), NULL, NULL);
 513         if (ret < 0)
 514                 goto error;
 515
 516         conn->params.key = key;
 517         _leave(" = 0 [%d]", key_serial(key));
 518         return 0;
 519
 520 error:
 521         key_revoke(key);
 522         key_put(key);
 523         _leave(" = -ENOMEM [ins %d]", ret);
 524         return -ENOMEM;
 525 }
 526 EXPORT_SYMBOL(rxrpc_get_server_data_key);
 527
 528 /**
 529  * rxrpc_get_null_key - Generate a null RxRPC key
 530  * @keyname: The name to give the key.
 531  *
 532  * Generate a null RxRPC key that can be used to indicate anonymous security is
 533  * required for a particular domain.
 534  */
 535 struct key *rxrpc_get_null_key(const char *keyname)
 536 {
 537         const struct cred *cred = current_cred();
 538         struct key *key;
 539         int ret;
 540
 541         key = key_alloc(&key_type_rxrpc, keyname,
 542                         GLOBAL_ROOT_UID, GLOBAL_ROOT_GID, cred,
 543                         KEY_POS_SEARCH, KEY_ALLOC_NOT_IN_QUOTA, NULL);
 544         if (IS_ERR(key))
 545                 return key;
 546
 547         ret = key_instantiate_and_link(key, NULL, 0, NULL, NULL);
 548         if (ret < 0) {
 549                 key_revoke(key);
 550                 key_put(key);
 551                 return ERR_PTR(ret);
 552         }
 553
 554         return key;
 555 }
 556 EXPORT_SYMBOL(rxrpc_get_null_key);
 557
 558 /*
 559  * read the contents of an rxrpc key
 560  * - this returns the result in XDR form
 561  */
 562 static long rxrpc_read(const struct key *key,
 563                        char *buffer, size_t buflen)
 564 {
 565         const struct rxrpc_key_token *token;
 566         size_t size;
 567         __be32 *xdr, *oldxdr;
 568         u32 cnlen, toksize, ntoks, tok, zero;
 569         u16 toksizes[AFSTOKEN_MAX];
 570
 571         _enter("");
 572
 573         /* we don't know what form we should return non-AFS keys in */
 574         if (memcmp(key->description, "afs@", 4) != 0)
 575                 return -EOPNOTSUPP;
 576         cnlen = strlen(key->description + 4);
 577
 578 #define RND(X) (((X) + 3) & ~3)
 579
 580         /* AFS keys we return in XDR form, so we need to work out the size of
 581          * the XDR */
 582         size = 2 * 4;   /* flags, cellname len */
 583         size += RND(cnlen);     /* cellname */
 584         size += 1 * 4;  /* token count */
 585
 586         ntoks = 0;
 587         for (token = key->payload.data[0]; token; token = token->next) {
 588                 toksize = 4;    /* sec index */
 589
 590                 switch (token->security_index) {
 591                 case RXRPC_SECURITY_RXKAD:
 592                         toksize += 8 * 4;       /* viceid, kvno, key*2, begin,
 593                                                  * end, primary, tktlen */
 594                         if (!token->no_leak_key)
 595                                 toksize += RND(token->kad->ticket_len);
 596                         break;
 597
 598                 default: /* we have a ticket we can't encode */
 599                         pr_err("Unsupported key token type (%u)\n",
 600                                token->security_index);
 601                         return -ENOPKG;
 602                 }
 603
 604                 _debug("token[%u]: toksize=%u", ntoks, toksize);
 605                 ASSERTCMP(toksize, <=, AFSTOKEN_LENGTH_MAX);
 606
 607                 toksizes[ntoks++] = toksize;
 608                 size += toksize + 4; /* each token has a length word */
 609         }
 610
 611 #undef RND
 612
 613         if (!buffer || buflen < size)
 614                 return size;
 615
 616         xdr = (__be32 *)buffer;
 617         zero = 0;
 618 #define ENCODE(x)                               \
 619         do {                                    \
 620                 *xdr++ = htonl(x);              \
 621         } while(0)
 622 #define ENCODE_DATA(l, s)                                               \
 623         do {                                                            \
 624                 u32 _l = (l);                                           \
 625                 ENCODE(l);                                              \
 626                 memcpy(xdr, (s), _l);                                   \
 627                 if (_l & 3)                                             \
 628                         memcpy((u8 *)xdr + _l, &zero, 4 - (_l & 3));    \
 629                 xdr += (_l + 3) >> 2;                                   \
 630         } while(0)
 631 #define ENCODE_BYTES(l, s)                                              \
 632         do {                                                            \
 633                 u32 _l = (l);                                           \
 634                 memcpy(xdr, (s), _l);                                   \
 635                 if (_l & 3)                                             \
 636                         memcpy((u8 *)xdr + _l, &zero, 4 - (_l & 3));    \
 637                 xdr += (_l + 3) >> 2;                                   \
 638         } while(0)
 639 #define ENCODE64(x)                                     \
 640         do {                                            \
 641                 __be64 y = cpu_to_be64(x);              \
 642                 memcpy(xdr, &y, 8);                     \
 643                 xdr += 8 >> 2;                          \
 644         } while(0)
 645 #define ENCODE_STR(s)                           \
 646         do {                                    \
 647                 const char *_s = (s);           \
 648                 ENCODE_DATA(strlen(_s), _s);    \
 649         } while(0)
 650
 651         ENCODE(0);                                      /* flags */
 652         ENCODE_DATA(cnlen, key->description + 4);       /* cellname */
 653         ENCODE(ntoks);
 654
 655         tok = 0;
 656         for (token = key->payload.data[0]; token; token = token->next) {
 657                 toksize = toksizes[tok++];
 658                 ENCODE(toksize);
 659                 oldxdr = xdr;
 660                 ENCODE(token->security_index);
 661
 662                 switch (token->security_index) {
 663                 case RXRPC_SECURITY_RXKAD:
 664                         ENCODE(token->kad->vice_id);
 665                         ENCODE(token->kad->kvno);
 666                         ENCODE_BYTES(8, token->kad->session_key);
 667                         ENCODE(token->kad->start);
 668                         ENCODE(token->kad->expiry);
 669                         ENCODE(token->kad->primary_flag);
 670                         if (token->no_leak_key)
 671                                 ENCODE(0);
 672                         else
 673                                 ENCODE_DATA(token->kad->ticket_len, token->kad->ticket);
 674                         break;
 675
 676                 default:
 677                         pr_err("Unsupported key token type (%u)\n",
 678                                token->security_index);
 679                         return -ENOPKG;
 680                 }
 681
 682                 ASSERTCMP((unsigned long)xdr - (unsigned long)oldxdr, ==,
 683                           toksize);
 684         }
 685
 686 #undef ENCODE_STR
 687 #undef ENCODE_DATA
 688 #undef ENCODE64
 689 #undef ENCODE
 690
 691         ASSERTCMP(tok, ==, ntoks);
 692         ASSERTCMP((char __user *) xdr - buffer, ==, size);
 693         _leave(" = %zu", size);
 694         return size;
 695 }