net/rxrpc/rxkad.c

   1 /* Kerberos-based RxRPC security
   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
  12 #include <linux/module.h>
  13 #include <linux/net.h>
  14 #include <linux/skbuff.h>
  15 #include <linux/udp.h>
  16 #include <linux/crypto.h>
  17 #include <linux/scatterlist.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 #define rxrpc_debug rxkad_debug
  24 #include "ar-internal.h"
  25
  26 #define RXKAD_VERSION                   2
  27 #define MAXKRB5TICKETLEN                1024
  28 #define RXKAD_TKT_TYPE_KERBEROS_V5      256
  29 #define ANAME_SZ                        40      /* size of authentication name */
  30 #define INST_SZ                         40      /* size of principal's instance */
  31 #define REALM_SZ                        40      /* size of principal's auth domain */
  32 #define SNAME_SZ                        40      /* size of service name */
  33
  34 unsigned int rxrpc_debug;
  35 module_param_named(debug, rxrpc_debug, uint, S_IWUSR | S_IRUGO);
  36 MODULE_PARM_DESC(debug, "rxkad debugging mask");
  37
  38 struct rxkad_level1_hdr {
  39         __be32  data_size;      /* true data size (excluding padding) */
  40 };
  41
  42 struct rxkad_level2_hdr {
  43         __be32  data_size;      /* true data size (excluding padding) */
  44         __be32  checksum;       /* decrypted data checksum */
  45 };
  46
  47 MODULE_DESCRIPTION("RxRPC network protocol type-2 security (Kerberos 4)");
  48 MODULE_AUTHOR("Red Hat, Inc.");
  49 MODULE_LICENSE("GPL");
  50
  51 /*
  52  * this holds a pinned cipher so that keventd doesn't get called by the cipher
  53  * alloc routine, but since we have it to hand, we use it to decrypt RESPONSE
  54  * packets
  55  */
  56 static struct crypto_blkcipher *rxkad_ci;
  57 static DEFINE_MUTEX(rxkad_ci_mutex);
  58
  59 /*
  60  * initialise connection security
  61  */
  62 static int rxkad_init_connection_security(struct rxrpc_connection *conn)
  63 {
  64         struct crypto_blkcipher *ci;
  65         struct rxrpc_key_token *token;
  66         int ret;
  67
  68         _enter("{%d},{%x}", conn->debug_id, key_serial(conn->key));
  69
  70         token = conn->key->payload.data[0];
  71         conn->security_ix = token->security_index;
  72
  73         ci = crypto_alloc_blkcipher("pcbc(fcrypt)", 0, CRYPTO_ALG_ASYNC);
  74         if (IS_ERR(ci)) {
  75                 _debug("no cipher");
  76                 ret = PTR_ERR(ci);
  77                 goto error;
  78         }
  79
  80         if (crypto_blkcipher_setkey(ci, token->kad->session_key,
  81                                     sizeof(token->kad->session_key)) < 0)
  82                 BUG();
  83
  84         switch (conn->security_level) {
  85         case RXRPC_SECURITY_PLAIN:
  86                 break;
  87         case RXRPC_SECURITY_AUTH:
  88                 conn->size_align = 8;
  89                 conn->security_size = sizeof(struct rxkad_level1_hdr);
  90                 conn->header_size += sizeof(struct rxkad_level1_hdr);
  91                 break;
  92         case RXRPC_SECURITY_ENCRYPT:
  93                 conn->size_align = 8;
  94                 conn->security_size = sizeof(struct rxkad_level2_hdr);
  95                 conn->header_size += sizeof(struct rxkad_level2_hdr);
  96                 break;
  97         default:
  98                 ret = -EKEYREJECTED;
  99                 goto error;
 100         }
 101
 102         conn->cipher = ci;
 103         ret = 0;
 104 error:
 105         _leave(" = %d", ret);
 106         return ret;
 107 }
 108
 109 /*
 110  * prime the encryption state with the invariant parts of a connection's
 111  * description
 112  */
 113 static void rxkad_prime_packet_security(struct rxrpc_connection *conn)
 114 {
 115         struct rxrpc_key_token *token;
 116         struct blkcipher_desc desc;
 117         struct scatterlist sg[2];
 118         struct rxrpc_crypt iv;
 119         struct {
 120                 __be32 x[4];
 121         } tmpbuf __attribute__((aligned(16))); /* must all be in same page */
 122
 123         _enter("");
 124
 125         if (!conn->key)
 126                 return;
 127
 128         token = conn->key->payload.data[0];
 129         memcpy(&iv, token->kad->session_key, sizeof(iv));
 130
 131         desc.tfm = conn->cipher;
 132         desc.info = iv.x;
 133         desc.flags = 0;
 134
 135         tmpbuf.x[0] = conn->epoch;
 136         tmpbuf.x[1] = conn->cid;
 137         tmpbuf.x[2] = 0;
 138         tmpbuf.x[3] = htonl(conn->security_ix);
 139
 140         sg_init_one(&sg[0], &tmpbuf, sizeof(tmpbuf));
 141         sg_init_one(&sg[1], &tmpbuf, sizeof(tmpbuf));
 142         crypto_blkcipher_encrypt_iv(&desc, &sg[0], &sg[1], sizeof(tmpbuf));
 143
 144         memcpy(&conn->csum_iv, &tmpbuf.x[2], sizeof(conn->csum_iv));
 145         ASSERTCMP(conn->csum_iv.n[0], ==, tmpbuf.x[2]);
 146
 147         _leave("");
 148 }
 149
 150 /*
 151  * partially encrypt a packet (level 1 security)
 152  */
 153 static int rxkad_secure_packet_auth(const struct rxrpc_call *call,
 154                                     struct sk_buff *skb,
 155                                     u32 data_size,
 156                                     void *sechdr)
 157 {
 158         struct rxrpc_skb_priv *sp;
 159         struct blkcipher_desc desc;
 160         struct rxrpc_crypt iv;
 161         struct scatterlist sg[2];
 162         struct {
 163                 struct rxkad_level1_hdr hdr;
 164                 __be32  first;  /* first four bytes of data and padding */
 165         } tmpbuf __attribute__((aligned(8))); /* must all be in same page */
 166         u16 check;
 167
 168         sp = rxrpc_skb(skb);
 169
 170         _enter("");
 171
 172         check = ntohl(sp->hdr.seq ^ sp->hdr.callNumber);
 173         data_size |= (u32) check << 16;
 174
 175         tmpbuf.hdr.data_size = htonl(data_size);
 176         memcpy(&tmpbuf.first, sechdr + 4, sizeof(tmpbuf.first));
 177
 178         /* start the encryption afresh */
 179         memset(&iv, 0, sizeof(iv));
 180         desc.tfm = call->conn->cipher;
 181         desc.info = iv.x;
 182         desc.flags = 0;
 183
 184         sg_init_one(&sg[0], &tmpbuf, sizeof(tmpbuf));
 185         sg_init_one(&sg[1], &tmpbuf, sizeof(tmpbuf));
 186         crypto_blkcipher_encrypt_iv(&desc, &sg[0], &sg[1], sizeof(tmpbuf));
 187
 188         memcpy(sechdr, &tmpbuf, sizeof(tmpbuf));
 189
 190         _leave(" = 0");
 191         return 0;
 192 }
 193
 194 /*
 195  * wholly encrypt a packet (level 2 security)
 196  */
 197 static int rxkad_secure_packet_encrypt(const struct rxrpc_call *call,
 198                                         struct sk_buff *skb,
 199                                         u32 data_size,
 200                                         void *sechdr)
 201 {
 202         const struct rxrpc_key_token *token;
 203         struct rxkad_level2_hdr rxkhdr
 204                 __attribute__((aligned(8))); /* must be all on one page */
 205         struct rxrpc_skb_priv *sp;
 206         struct blkcipher_desc desc;
 207         struct rxrpc_crypt iv;
 208         struct scatterlist sg[16];
 209         struct sk_buff *trailer;
 210         unsigned int len;
 211         u16 check;
 212         int nsg, err;
 213
 214         sp = rxrpc_skb(skb);
 215
 216         _enter("");
 217
 218         check = ntohl(sp->hdr.seq ^ sp->hdr.callNumber);
 219
 220         rxkhdr.data_size = htonl(data_size | (u32) check << 16);
 221         rxkhdr.checksum = 0;
 222
 223         /* encrypt from the session key */
 224         token = call->conn->key->payload.data[0];
 225         memcpy(&iv, token->kad->session_key, sizeof(iv));
 226         desc.tfm = call->conn->cipher;
 227         desc.info = iv.x;
 228         desc.flags = 0;
 229
 230         sg_init_one(&sg[0], sechdr, sizeof(rxkhdr));
 231         sg_init_one(&sg[1], &rxkhdr, sizeof(rxkhdr));
 232         crypto_blkcipher_encrypt_iv(&desc, &sg[0], &sg[1], sizeof(rxkhdr));
 233
 234         /* we want to encrypt the skbuff in-place */
 235         nsg = skb_cow_data(skb, 0, &trailer);
 236         if (nsg < 0 || nsg > 16)
 237                 return -ENOMEM;
 238
 239         len = data_size + call->conn->size_align - 1;
 240         len &= ~(call->conn->size_align - 1);
 241
 242         sg_init_table(sg, nsg);
 243         err = skb_to_sgvec(skb, sg, 0, len);
 244         if (unlikely(err < 0))
 245                 return err;
 246         crypto_blkcipher_encrypt_iv(&desc, sg, sg, len);
 247
 248         _leave(" = 0");
 249         return 0;
 250 }
 251
 252 /*
 253  * checksum an RxRPC packet header
 254  */
 255 static int rxkad_secure_packet(const struct rxrpc_call *call,
 256                                 struct sk_buff *skb,
 257                                 size_t data_size,
 258                                 void *sechdr)
 259 {
 260         struct rxrpc_skb_priv *sp;
 261         struct blkcipher_desc desc;
 262         struct rxrpc_crypt iv;
 263         struct scatterlist sg[2];
 264         struct {
 265                 __be32 x[2];
 266         } tmpbuf __attribute__((aligned(8))); /* must all be in same page */
 267         __be32 x;
 268         u32 y;
 269         int ret;
 270
 271         sp = rxrpc_skb(skb);
 272
 273         _enter("{%d{%x}},{#%u},%zu,",
 274                call->debug_id, key_serial(call->conn->key), ntohl(sp->hdr.seq),
 275                data_size);
 276
 277         if (!call->conn->cipher)
 278                 return 0;
 279
 280         ret = key_validate(call->conn->key);
 281         if (ret < 0)
 282                 return ret;
 283
 284         /* continue encrypting from where we left off */
 285         memcpy(&iv, call->conn->csum_iv.x, sizeof(iv));
 286         desc.tfm = call->conn->cipher;
 287         desc.info = iv.x;
 288         desc.flags = 0;
 289
 290         /* calculate the security checksum */
 291         x = htonl(call->channel << (32 - RXRPC_CIDSHIFT));
 292         x |= sp->hdr.seq & cpu_to_be32(0x3fffffff);
 293         tmpbuf.x[0] = sp->hdr.callNumber;
 294         tmpbuf.x[1] = x;
 295
 296         sg_init_one(&sg[0], &tmpbuf, sizeof(tmpbuf));
 297         sg_init_one(&sg[1], &tmpbuf, sizeof(tmpbuf));
 298         crypto_blkcipher_encrypt_iv(&desc, &sg[0], &sg[1], sizeof(tmpbuf));
 299
 300         y = ntohl(tmpbuf.x[1]);
 301         y = (y >> 16) & 0xffff;
 302         if (y == 0)
 303                 y = 1; /* zero checksums are not permitted */
 304         sp->hdr.cksum = htons(y);
 305
 306         switch (call->conn->security_level) {
 307         case RXRPC_SECURITY_PLAIN:
 308                 ret = 0;
 309                 break;
 310         case RXRPC_SECURITY_AUTH:
 311                 ret = rxkad_secure_packet_auth(call, skb, data_size, sechdr);
 312                 break;
 313         case RXRPC_SECURITY_ENCRYPT:
 314                 ret = rxkad_secure_packet_encrypt(call, skb, data_size,
 315                                                   sechdr);
 316                 break;
 317         default:
 318                 ret = -EPERM;
 319                 break;
 320         }
 321
 322         _leave(" = %d [set %hx]", ret, y);
 323         return ret;
 324 }
 325
 326 /*
 327  * decrypt partial encryption on a packet (level 1 security)
 328  */
 329 static int rxkad_verify_packet_auth(const struct rxrpc_call *call,
 330                                     struct sk_buff *skb,
 331                                     u32 *_abort_code)
 332 {
 333         struct rxkad_level1_hdr sechdr;
 334         struct rxrpc_skb_priv *sp;
 335         struct blkcipher_desc desc;
 336         struct rxrpc_crypt iv;
 337         struct scatterlist sg[16];
 338         struct sk_buff *trailer;
 339         u32 data_size, buf;
 340         u16 check;
 341         int nsg, ret;
 342
 343         _enter("");
 344
 345         sp = rxrpc_skb(skb);
 346
 347         /* we want to decrypt the skbuff in-place */
 348         nsg = skb_cow_data(skb, 0, &trailer);
 349         if (nsg < 0 || nsg > 16)
 350                 goto nomem;
 351
 352         sg_init_table(sg, nsg);
 353         ret = skb_to_sgvec(skb, sg, 0, 8);
 354         if (unlikely(ret < 0))
 355                 return ret;
 356
 357         /* start the decryption afresh */
 358         memset(&iv, 0, sizeof(iv));
 359         desc.tfm = call->conn->cipher;
 360         desc.info = iv.x;
 361         desc.flags = 0;
 362
 363         crypto_blkcipher_decrypt_iv(&desc, sg, sg, 8);
 364
 365         /* remove the decrypted packet length */
 366         if (skb_copy_bits(skb, 0, &sechdr, sizeof(sechdr)) < 0)
 367                 goto datalen_error;
 368         if (!skb_pull(skb, sizeof(sechdr)))
 369                 BUG();
 370
 371         buf = ntohl(sechdr.data_size);
 372         data_size = buf & 0xffff;
 373
 374         check = buf >> 16;
 375         check ^= ntohl(sp->hdr.seq ^ sp->hdr.callNumber);
 376         check &= 0xffff;
 377         if (check != 0) {
 378                 *_abort_code = RXKADSEALEDINCON;
 379                 goto protocol_error;
 380         }
 381
 382         /* shorten the packet to remove the padding */
 383         if (data_size > skb->len)
 384                 goto datalen_error;
 385         else if (data_size < skb->len)
 386                 skb->len = data_size;
 387
 388         _leave(" = 0 [dlen=%x]", data_size);
 389         return 0;
 390
 391 datalen_error:
 392         *_abort_code = RXKADDATALEN;
 393 protocol_error:
 394         _leave(" = -EPROTO");
 395         return -EPROTO;
 396
 397 nomem:
 398         _leave(" = -ENOMEM");
 399         return -ENOMEM;
 400 }
 401
 402 /*
 403  * wholly decrypt a packet (level 2 security)
 404  */
 405 static int rxkad_verify_packet_encrypt(const struct rxrpc_call *call,
 406                                        struct sk_buff *skb,
 407                                        u32 *_abort_code)
 408 {
 409         const struct rxrpc_key_token *token;
 410         struct rxkad_level2_hdr sechdr;
 411         struct rxrpc_skb_priv *sp;
 412         struct blkcipher_desc desc;
 413         struct rxrpc_crypt iv;
 414         struct scatterlist _sg[4], *sg;
 415         struct sk_buff *trailer;
 416         u32 data_size, buf;
 417         u16 check;
 418         int nsg, ret;
 419
 420         _enter(",{%d}", skb->len);
 421
 422         sp = rxrpc_skb(skb);
 423
 424         /* we want to decrypt the skbuff in-place */
 425         nsg = skb_cow_data(skb, 0, &trailer);
 426         if (nsg < 0)
 427                 goto nomem;
 428
 429         sg = _sg;
 430         if (unlikely(nsg > 4)) {
 431                 sg = kmalloc(sizeof(*sg) * nsg, GFP_NOIO);
 432                 if (!sg)
 433                         goto nomem;
 434         }
 435
 436         sg_init_table(sg, nsg);
 437         ret = skb_to_sgvec(skb, sg, 0, skb->len);
 438         if (unlikely(ret < 0)) {
 439                 if (sg != _sg)
 440                         kfree(sg);
 441                 return ret;
 442         }
 443
 444         /* decrypt from the session key */
 445         token = call->conn->key->payload.data[0];
 446         memcpy(&iv, token->kad->session_key, sizeof(iv));
 447         desc.tfm = call->conn->cipher;
 448         desc.info = iv.x;
 449         desc.flags = 0;
 450
 451         crypto_blkcipher_decrypt_iv(&desc, sg, sg, skb->len);
 452         if (sg != _sg)
 453                 kfree(sg);
 454
 455         /* remove the decrypted packet length */
 456         if (skb_copy_bits(skb, 0, &sechdr, sizeof(sechdr)) < 0)
 457                 goto datalen_error;
 458         if (!skb_pull(skb, sizeof(sechdr)))
 459                 BUG();
 460
 461         buf = ntohl(sechdr.data_size);
 462         data_size = buf & 0xffff;
 463
 464         check = buf >> 16;
 465         check ^= ntohl(sp->hdr.seq ^ sp->hdr.callNumber);
 466         check &= 0xffff;
 467         if (check != 0) {
 468                 *_abort_code = RXKADSEALEDINCON;
 469                 goto protocol_error;
 470         }
 471
 472         /* shorten the packet to remove the padding */
 473         if (data_size > skb->len)
 474                 goto datalen_error;
 475         else if (data_size < skb->len)
 476                 skb->len = data_size;
 477
 478         _leave(" = 0 [dlen=%x]", data_size);
 479         return 0;
 480
 481 datalen_error:
 482         *_abort_code = RXKADDATALEN;
 483 protocol_error:
 484         _leave(" = -EPROTO");
 485         return -EPROTO;
 486
 487 nomem:
 488         _leave(" = -ENOMEM");
 489         return -ENOMEM;
 490 }
 491
 492 /*
 493  * verify the security on a received packet
 494  */
 495 static int rxkad_verify_packet(const struct rxrpc_call *call,
 496                                struct sk_buff *skb,
 497                                u32 *_abort_code)
 498 {
 499         struct blkcipher_desc desc;
 500         struct rxrpc_skb_priv *sp;
 501         struct rxrpc_crypt iv;
 502         struct scatterlist sg[2];
 503         struct {
 504                 __be32 x[2];
 505         } tmpbuf __attribute__((aligned(8))); /* must all be in same page */
 506         __be32 x;
 507         __be16 cksum;
 508         u32 y;
 509         int ret;
 510
 511         sp = rxrpc_skb(skb);
 512
 513         _enter("{%d{%x}},{#%u}",
 514                call->debug_id, key_serial(call->conn->key),
 515                ntohl(sp->hdr.seq));
 516
 517         if (!call->conn->cipher)
 518                 return 0;
 519
 520         if (sp->hdr.securityIndex != RXRPC_SECURITY_RXKAD) {
 521                 *_abort_code = RXKADINCONSISTENCY;
 522                 _leave(" = -EPROTO [not rxkad]");
 523                 return -EPROTO;
 524         }
 525
 526         /* continue encrypting from where we left off */
 527         memcpy(&iv, call->conn->csum_iv.x, sizeof(iv));
 528         desc.tfm = call->conn->cipher;
 529         desc.info = iv.x;
 530         desc.flags = 0;
 531
 532         /* validate the security checksum */
 533         x = htonl(call->channel << (32 - RXRPC_CIDSHIFT));
 534         x |= sp->hdr.seq & cpu_to_be32(0x3fffffff);
 535         tmpbuf.x[0] = call->call_id;
 536         tmpbuf.x[1] = x;
 537
 538         sg_init_one(&sg[0], &tmpbuf, sizeof(tmpbuf));
 539         sg_init_one(&sg[1], &tmpbuf, sizeof(tmpbuf));
 540         crypto_blkcipher_encrypt_iv(&desc, &sg[0], &sg[1], sizeof(tmpbuf));
 541
 542         y = ntohl(tmpbuf.x[1]);
 543         y = (y >> 16) & 0xffff;
 544         if (y == 0)
 545                 y = 1; /* zero checksums are not permitted */
 546
 547         cksum = htons(y);
 548         if (sp->hdr.cksum != cksum) {
 549                 *_abort_code = RXKADSEALEDINCON;
 550                 _leave(" = -EPROTO [csum failed]");
 551                 return -EPROTO;
 552         }
 553
 554         switch (call->conn->security_level) {
 555         case RXRPC_SECURITY_PLAIN:
 556                 ret = 0;
 557                 break;
 558         case RXRPC_SECURITY_AUTH:
 559                 ret = rxkad_verify_packet_auth(call, skb, _abort_code);
 560                 break;
 561         case RXRPC_SECURITY_ENCRYPT:
 562                 ret = rxkad_verify_packet_encrypt(call, skb, _abort_code);
 563                 break;
 564         default:
 565                 ret = -ENOANO;
 566                 break;
 567         }
 568
 569         _leave(" = %d", ret);
 570         return ret;
 571 }
 572
 573 /*
 574  * issue a challenge
 575  */
 576 static int rxkad_issue_challenge(struct rxrpc_connection *conn)
 577 {
 578         struct rxkad_challenge challenge;
 579         struct rxrpc_header hdr;
 580         struct msghdr msg;
 581         struct kvec iov[2];
 582         size_t len;
 583         int ret;
 584
 585         _enter("{%d,%x}", conn->debug_id, key_serial(conn->key));
 586
 587         ret = key_validate(conn->key);
 588         if (ret < 0)
 589                 return ret;
 590
 591         get_random_bytes(&conn->security_nonce, sizeof(conn->security_nonce));
 592
 593         challenge.version       = htonl(2);
 594         challenge.nonce         = htonl(conn->security_nonce);
 595         challenge.min_level     = htonl(0);
 596         challenge.__padding     = 0;
 597
 598         msg.msg_name    = &conn->trans->peer->srx.transport.sin;
 599         msg.msg_namelen = sizeof(conn->trans->peer->srx.transport.sin);
 600         msg.msg_control = NULL;
 601         msg.msg_controllen = 0;
 602         msg.msg_flags   = 0;
 603
 604         hdr.epoch       = conn->epoch;
 605         hdr.cid         = conn->cid;
 606         hdr.callNumber  = 0;
 607         hdr.seq         = 0;
 608         hdr.type        = RXRPC_PACKET_TYPE_CHALLENGE;
 609         hdr.flags       = conn->out_clientflag;
 610         hdr.userStatus  = 0;
 611         hdr.securityIndex = conn->security_ix;
 612         hdr._rsvd       = 0;
 613         hdr.serviceId   = conn->service_id;
 614
 615         iov[0].iov_base = &hdr;
 616         iov[0].iov_len  = sizeof(hdr);
 617         iov[1].iov_base = &challenge;
 618         iov[1].iov_len  = sizeof(challenge);
 619
 620         len = iov[0].iov_len + iov[1].iov_len;
 621
 622         hdr.serial = htonl(atomic_inc_return(&conn->serial));
 623         _proto("Tx CHALLENGE %%%u", ntohl(hdr.serial));
 624
 625         ret = kernel_sendmsg(conn->trans->local->socket, &msg, iov, 2, len);
 626         if (ret < 0) {
 627                 _debug("sendmsg failed: %d", ret);
 628                 return -EAGAIN;
 629         }
 630
 631         _leave(" = 0");
 632         return 0;
 633 }
 634
 635 /*
 636  * send a Kerberos security response
 637  */
 638 static int rxkad_send_response(struct rxrpc_connection *conn,
 639                                struct rxrpc_header *hdr,
 640                                struct rxkad_response *resp,
 641                                const struct rxkad_key *s2)
 642 {
 643         struct msghdr msg;
 644         struct kvec iov[3];
 645         size_t len;
 646         int ret;
 647
 648         _enter("");
 649
 650         msg.msg_name    = &conn->trans->peer->srx.transport.sin;
 651         msg.msg_namelen = sizeof(conn->trans->peer->srx.transport.sin);
 652         msg.msg_control = NULL;
 653         msg.msg_controllen = 0;
 654         msg.msg_flags   = 0;
 655
 656         hdr->epoch      = conn->epoch;
 657         hdr->seq        = 0;
 658         hdr->type       = RXRPC_PACKET_TYPE_RESPONSE;
 659         hdr->flags      = conn->out_clientflag;
 660         hdr->userStatus = 0;
 661         hdr->_rsvd      = 0;
 662
 663         iov[0].iov_base = hdr;
 664         iov[0].iov_len  = sizeof(*hdr);
 665         iov[1].iov_base = resp;
 666         iov[1].iov_len  = sizeof(*resp);
 667         iov[2].iov_base = (void *) s2->ticket;
 668         iov[2].iov_len  = s2->ticket_len;
 669
 670         len = iov[0].iov_len + iov[1].iov_len + iov[2].iov_len;
 671
 672         hdr->serial = htonl(atomic_inc_return(&conn->serial));
 673         _proto("Tx RESPONSE %%%u", ntohl(hdr->serial));
 674
 675         ret = kernel_sendmsg(conn->trans->local->socket, &msg, iov, 3, len);
 676         if (ret < 0) {
 677                 _debug("sendmsg failed: %d", ret);
 678                 return -EAGAIN;
 679         }
 680
 681         _leave(" = 0");
 682         return 0;
 683 }
 684
 685 /*
 686  * calculate the response checksum
 687  */
 688 static void rxkad_calc_response_checksum(struct rxkad_response *response)
 689 {
 690         u32 csum = 1000003;
 691         int loop;
 692         u8 *p = (u8 *) response;
 693
 694         for (loop = sizeof(*response); loop > 0; loop--)
 695                 csum = csum * 0x10204081 + *p++;
 696
 697         response->encrypted.checksum = htonl(csum);
 698 }
 699
 700 /*
 701  * load a scatterlist with a potentially split-page buffer
 702  */
 703 static void rxkad_sg_set_buf2(struct scatterlist sg[2],
 704                               void *buf, size_t buflen)
 705 {
 706         int nsg = 1;
 707
 708         sg_init_table(sg, 2);
 709
 710         sg_set_buf(&sg[0], buf, buflen);
 711         if (sg[0].offset + buflen > PAGE_SIZE) {
 712                 /* the buffer was split over two pages */
 713                 sg[0].length = PAGE_SIZE - sg[0].offset;
 714                 sg_set_buf(&sg[1], buf + sg[0].length, buflen - sg[0].length);
 715                 nsg++;
 716         }
 717
 718         sg_mark_end(&sg[nsg - 1]);
 719
 720         ASSERTCMP(sg[0].length + sg[1].length, ==, buflen);
 721 }
 722
 723 /*
 724  * encrypt the response packet
 725  */
 726 static void rxkad_encrypt_response(struct rxrpc_connection *conn,
 727                                    struct rxkad_response *resp,
 728                                    const struct rxkad_key *s2)
 729 {
 730         struct blkcipher_desc desc;
 731         struct rxrpc_crypt iv;
 732         struct scatterlist sg[2];
 733
 734         /* continue encrypting from where we left off */
 735         memcpy(&iv, s2->session_key, sizeof(iv));
 736         desc.tfm = conn->cipher;
 737         desc.info = iv.x;
 738         desc.flags = 0;
 739
 740         rxkad_sg_set_buf2(sg, &resp->encrypted, sizeof(resp->encrypted));
 741         crypto_blkcipher_encrypt_iv(&desc, sg, sg, sizeof(resp->encrypted));
 742 }
 743
 744 /*
 745  * respond to a challenge packet
 746  */
 747 static int rxkad_respond_to_challenge(struct rxrpc_connection *conn,
 748                                       struct sk_buff *skb,
 749                                       u32 *_abort_code)
 750 {
 751         const struct rxrpc_key_token *token;
 752         struct rxkad_challenge challenge;
 753         struct rxkad_response resp
 754                 __attribute__((aligned(8))); /* must be aligned for crypto */
 755         struct rxrpc_skb_priv *sp;
 756         u32 version, nonce, min_level, abort_code;
 757         int ret;
 758
 759         _enter("{%d,%x}", conn->debug_id, key_serial(conn->key));
 760
 761         if (!conn->key) {
 762                 _leave(" = -EPROTO [no key]");
 763                 return -EPROTO;
 764         }
 765
 766         ret = key_validate(conn->key);
 767         if (ret < 0) {
 768                 *_abort_code = RXKADEXPIRED;
 769                 return ret;
 770         }
 771
 772         abort_code = RXKADPACKETSHORT;
 773         sp = rxrpc_skb(skb);
 774         if (skb_copy_bits(skb, 0, &challenge, sizeof(challenge)) < 0)
 775                 goto protocol_error;
 776
 777         version = ntohl(challenge.version);
 778         nonce = ntohl(challenge.nonce);
 779         min_level = ntohl(challenge.min_level);
 780
 781         _proto("Rx CHALLENGE %%%u { v=%u n=%u ml=%u }",
 782                ntohl(sp->hdr.serial), version, nonce, min_level);
 783
 784         abort_code = RXKADINCONSISTENCY;
 785         if (version != RXKAD_VERSION)
 786                 goto protocol_error;
 787
 788         abort_code = RXKADLEVELFAIL;
 789         if (conn->security_level < min_level)
 790                 goto protocol_error;
 791
 792         token = conn->key->payload.data[0];
 793
 794         /* build the response packet */
 795         memset(&resp, 0, sizeof(resp));
 796
 797         resp.version = RXKAD_VERSION;
 798         resp.encrypted.epoch = conn->epoch;
 799         resp.encrypted.cid = conn->cid;
 800         resp.encrypted.securityIndex = htonl(conn->security_ix);
 801         resp.encrypted.call_id[0] =
 802                 (conn->channels[0] ? conn->channels[0]->call_id : 0);
 803         resp.encrypted.call_id[1] =
 804                 (conn->channels[1] ? conn->channels[1]->call_id : 0);
 805         resp.encrypted.call_id[2] =
 806                 (conn->channels[2] ? conn->channels[2]->call_id : 0);
 807         resp.encrypted.call_id[3] =
 808                 (conn->channels[3] ? conn->channels[3]->call_id : 0);
 809         resp.encrypted.inc_nonce = htonl(nonce + 1);
 810         resp.encrypted.level = htonl(conn->security_level);
 811         resp.kvno = htonl(token->kad->kvno);
 812         resp.ticket_len = htonl(token->kad->ticket_len);
 813
 814         /* calculate the response checksum and then do the encryption */
 815         rxkad_calc_response_checksum(&resp);
 816         rxkad_encrypt_response(conn, &resp, token->kad);
 817         return rxkad_send_response(conn, &sp->hdr, &resp, token->kad);
 818
 819 protocol_error:
 820         *_abort_code = abort_code;
 821         _leave(" = -EPROTO [%d]", abort_code);
 822         return -EPROTO;
 823 }
 824
 825 /*
 826  * decrypt the kerberos IV ticket in the response
 827  */
 828 static int rxkad_decrypt_ticket(struct rxrpc_connection *conn,
 829                                 void *ticket, size_t ticket_len,
 830                                 struct rxrpc_crypt *_session_key,
 831                                 time_t *_expiry,
 832                                 u32 *_abort_code)
 833 {
 834         struct blkcipher_desc desc;
 835         struct rxrpc_crypt iv, key;
 836         struct scatterlist sg[1];
 837         struct in_addr addr;
 838         unsigned int life;
 839         time_t issue, now;
 840         bool little_endian;
 841         int ret;
 842         u8 *p, *q, *name, *end;
 843
 844         _enter("{%d},{%x}", conn->debug_id, key_serial(conn->server_key));
 845
 846         *_expiry = 0;
 847
 848         ret = key_validate(conn->server_key);
 849         if (ret < 0) {
 850                 switch (ret) {
 851                 case -EKEYEXPIRED:
 852                         *_abort_code = RXKADEXPIRED;
 853                         goto error;
 854                 default:
 855                         *_abort_code = RXKADNOAUTH;
 856                         goto error;
 857                 }
 858         }
 859
 860         ASSERT(conn->server_key->payload.data[0] != NULL);
 861         ASSERTCMP((unsigned long) ticket & 7UL, ==, 0);
 862
 863         memcpy(&iv, &conn->server_key->payload.data[2], sizeof(iv));
 864
 865         desc.tfm = conn->server_key->payload.data[0];
 866         desc.info = iv.x;
 867         desc.flags = 0;
 868
 869         sg_init_one(&sg[0], ticket, ticket_len);
 870         crypto_blkcipher_decrypt_iv(&desc, sg, sg, ticket_len);
 871
 872         p = ticket;
 873         end = p + ticket_len;
 874
 875 #define Z(size)                                         \
 876         ({                                              \
 877                 u8 *__str = p;                          \
 878                 q = memchr(p, 0, end - p);              \
 879                 if (!q || q - p > (size))               \
 880                         goto bad_ticket;                \
 881                 for (; p < q; p++)                      \
 882                         if (!isprint(*p))               \
 883                                 goto bad_ticket;        \
 884                 p++;                                    \
 885                 __str;                                  \
 886         })
 887
 888         /* extract the ticket flags */
 889         _debug("KIV FLAGS: %x", *p);
 890         little_endian = *p & 1;
 891         p++;
 892
 893         /* extract the authentication name */
 894         name = Z(ANAME_SZ);
 895         _debug("KIV ANAME: %s", name);
 896
 897         /* extract the principal's instance */
 898         name = Z(INST_SZ);
 899         _debug("KIV INST : %s", name);
 900
 901         /* extract the principal's authentication domain */
 902         name = Z(REALM_SZ);
 903         _debug("KIV REALM: %s", name);
 904
 905         if (end - p < 4 + 8 + 4 + 2)
 906                 goto bad_ticket;
 907
 908         /* get the IPv4 address of the entity that requested the ticket */
 909         memcpy(&addr, p, sizeof(addr));
 910         p += 4;
 911         _debug("KIV ADDR : %pI4", &addr);
 912
 913         /* get the session key from the ticket */
 914         memcpy(&key, p, sizeof(key));
 915         p += 8;
 916         _debug("KIV KEY  : %08x %08x", ntohl(key.n[0]), ntohl(key.n[1]));
 917         memcpy(_session_key, &key, sizeof(key));
 918
 919         /* get the ticket's lifetime */
 920         life = *p++ * 5 * 60;
 921         _debug("KIV LIFE : %u", life);
 922
 923         /* get the issue time of the ticket */
 924         if (little_endian) {
 925                 __le32 stamp;
 926                 memcpy(&stamp, p, 4);
 927                 issue = le32_to_cpu(stamp);
 928         } else {
 929                 __be32 stamp;
 930                 memcpy(&stamp, p, 4);
 931                 issue = be32_to_cpu(stamp);
 932         }
 933         p += 4;
 934         now = get_seconds();
 935         _debug("KIV ISSUE: %lx [%lx]", issue, now);
 936
 937         /* check the ticket is in date */
 938         if (issue > now) {
 939                 *_abort_code = RXKADNOAUTH;
 940                 ret = -EKEYREJECTED;
 941                 goto error;
 942         }
 943
 944         if (issue < now - life) {
 945                 *_abort_code = RXKADEXPIRED;
 946                 ret = -EKEYEXPIRED;
 947                 goto error;
 948         }
 949
 950         *_expiry = issue + life;
 951
 952         /* get the service name */
 953         name = Z(SNAME_SZ);
 954         _debug("KIV SNAME: %s", name);
 955
 956         /* get the service instance name */
 957         name = Z(INST_SZ);
 958         _debug("KIV SINST: %s", name);
 959
 960         ret = 0;
 961 error:
 962         _leave(" = %d", ret);
 963         return ret;
 964
 965 bad_ticket:
 966         *_abort_code = RXKADBADTICKET;
 967         ret = -EBADMSG;
 968         goto error;
 969 }
 970
 971 /*
 972  * decrypt the response packet
 973  */
 974 static void rxkad_decrypt_response(struct rxrpc_connection *conn,
 975                                    struct rxkad_response *resp,
 976                                    const struct rxrpc_crypt *session_key)
 977 {
 978         struct blkcipher_desc desc;
 979         struct scatterlist sg[2];
 980         struct rxrpc_crypt iv;
 981
 982         _enter(",,%08x%08x",
 983                ntohl(session_key->n[0]), ntohl(session_key->n[1]));
 984
 985         ASSERT(rxkad_ci != NULL);
 986
 987         mutex_lock(&rxkad_ci_mutex);
 988         if (crypto_blkcipher_setkey(rxkad_ci, session_key->x,
 989                                     sizeof(*session_key)) < 0)
 990                 BUG();
 991
 992         memcpy(&iv, session_key, sizeof(iv));
 993         desc.tfm = rxkad_ci;
 994         desc.info = iv.x;
 995         desc.flags = 0;
 996
 997         rxkad_sg_set_buf2(sg, &resp->encrypted, sizeof(resp->encrypted));
 998         crypto_blkcipher_decrypt_iv(&desc, sg, sg, sizeof(resp->encrypted));
 999         mutex_unlock(&rxkad_ci_mutex);
1000
1001         _leave("");
1002 }
1003
1004 /*
1005  * verify a response
1006  */
1007 static int rxkad_verify_response(struct rxrpc_connection *conn,
1008                                  struct sk_buff *skb,
1009                                  u32 *_abort_code)
1010 {
1011         struct rxkad_response response
1012                 __attribute__((aligned(8))); /* must be aligned for crypto */
1013         struct rxrpc_skb_priv *sp;
1014         struct rxrpc_crypt session_key;
1015         time_t expiry;
1016         void *ticket;
1017         u32 abort_code, version, kvno, ticket_len, level;
1018         __be32 csum;
1019         int ret;
1020
1021         _enter("{%d,%x}", conn->debug_id, key_serial(conn->server_key));
1022
1023         abort_code = RXKADPACKETSHORT;
1024         if (skb_copy_bits(skb, 0, &response, sizeof(response)) < 0)
1025                 goto protocol_error;
1026         if (!pskb_pull(skb, sizeof(response)))
1027                 BUG();
1028
1029         version = ntohl(response.version);
1030         ticket_len = ntohl(response.ticket_len);
1031         kvno = ntohl(response.kvno);
1032         sp = rxrpc_skb(skb);
1033         _proto("Rx RESPONSE %%%u { v=%u kv=%u tl=%u }",
1034                ntohl(sp->hdr.serial), version, kvno, ticket_len);
1035
1036         abort_code = RXKADINCONSISTENCY;
1037         if (version != RXKAD_VERSION)
1038                 goto protocol_error;
1039
1040         abort_code = RXKADTICKETLEN;
1041         if (ticket_len < 4 || ticket_len > MAXKRB5TICKETLEN)
1042                 goto protocol_error;
1043
1044         abort_code = RXKADUNKNOWNKEY;
1045         if (kvno >= RXKAD_TKT_TYPE_KERBEROS_V5)
1046                 goto protocol_error;
1047
1048         /* extract the kerberos ticket and decrypt and decode it */
1049         ticket = kmalloc(ticket_len, GFP_NOFS);
1050         if (!ticket)
1051                 return -ENOMEM;
1052
1053         abort_code = RXKADPACKETSHORT;
1054         if (skb_copy_bits(skb, 0, ticket, ticket_len) < 0)
1055                 goto protocol_error_free;
1056
1057         ret = rxkad_decrypt_ticket(conn, ticket, ticket_len, &session_key,
1058                                    &expiry, &abort_code);
1059         if (ret < 0) {
1060                 *_abort_code = abort_code;
1061                 kfree(ticket);
1062                 return ret;
1063         }
1064
1065         /* use the session key from inside the ticket to decrypt the
1066          * response */
1067         rxkad_decrypt_response(conn, &response, &session_key);
1068
1069         abort_code = RXKADSEALEDINCON;
1070         if (response.encrypted.epoch != conn->epoch)
1071                 goto protocol_error_free;
1072         if (response.encrypted.cid != conn->cid)
1073                 goto protocol_error_free;
1074         if (ntohl(response.encrypted.securityIndex) != conn->security_ix)
1075                 goto protocol_error_free;
1076         csum = response.encrypted.checksum;
1077         response.encrypted.checksum = 0;
1078         rxkad_calc_response_checksum(&response);
1079         if (response.encrypted.checksum != csum)
1080                 goto protocol_error_free;
1081
1082         if (ntohl(response.encrypted.call_id[0]) > INT_MAX ||
1083             ntohl(response.encrypted.call_id[1]) > INT_MAX ||
1084             ntohl(response.encrypted.call_id[2]) > INT_MAX ||
1085             ntohl(response.encrypted.call_id[3]) > INT_MAX)
1086                 goto protocol_error_free;
1087
1088         abort_code = RXKADOUTOFSEQUENCE;
1089         if (response.encrypted.inc_nonce != htonl(conn->security_nonce + 1))
1090                 goto protocol_error_free;
1091
1092         abort_code = RXKADLEVELFAIL;
1093         level = ntohl(response.encrypted.level);
1094         if (level > RXRPC_SECURITY_ENCRYPT)
1095                 goto protocol_error_free;
1096         conn->security_level = level;
1097
1098         /* create a key to hold the security data and expiration time - after
1099          * this the connection security can be handled in exactly the same way
1100          * as for a client connection */
1101         ret = rxrpc_get_server_data_key(conn, &session_key, expiry, kvno);
1102         if (ret < 0) {
1103                 kfree(ticket);
1104                 return ret;
1105         }
1106
1107         kfree(ticket);
1108         _leave(" = 0");
1109         return 0;
1110
1111 protocol_error_free:
1112         kfree(ticket);
1113 protocol_error:
1114         *_abort_code = abort_code;
1115         _leave(" = -EPROTO [%d]", abort_code);
1116         return -EPROTO;
1117 }
1118
1119 /*
1120  * clear the connection security
1121  */
1122 static void rxkad_clear(struct rxrpc_connection *conn)
1123 {
1124         _enter("");
1125
1126         if (conn->cipher)
1127                 crypto_free_blkcipher(conn->cipher);
1128 }
1129
1130 /*
1131  * RxRPC Kerberos-based security
1132  */
1133 static struct rxrpc_security rxkad = {
1134         .owner                          = THIS_MODULE,
1135         .name                           = "rxkad",
1136         .security_index                 = RXRPC_SECURITY_RXKAD,
1137         .init_connection_security       = rxkad_init_connection_security,
1138         .prime_packet_security          = rxkad_prime_packet_security,
1139         .secure_packet                  = rxkad_secure_packet,
1140         .verify_packet                  = rxkad_verify_packet,
1141         .issue_challenge                = rxkad_issue_challenge,
1142         .respond_to_challenge           = rxkad_respond_to_challenge,
1143         .verify_response                = rxkad_verify_response,
1144         .clear                          = rxkad_clear,
1145 };
1146
1147 static __init int rxkad_init(void)
1148 {
1149         _enter("");
1150
1151         /* pin the cipher we need so that the crypto layer doesn't invoke
1152          * keventd to go get it */
1153         rxkad_ci = crypto_alloc_blkcipher("pcbc(fcrypt)", 0, CRYPTO_ALG_ASYNC);
1154         if (IS_ERR(rxkad_ci))
1155                 return PTR_ERR(rxkad_ci);
1156
1157         return rxrpc_register_security(&rxkad);
1158 }
1159
1160 module_init(rxkad_init);
1161
1162 static __exit void rxkad_exit(void)
1163 {
1164         _enter("");
1165
1166         rxrpc_unregister_security(&rxkad);
1167         crypto_free_blkcipher(rxkad_ci);
1168 }
1169
1170 module_exit(rxkad_exit);