lustre/ptlrpc/gss/gss_krb5_mech.c

   1 /* -*- mode: c; c-basic-offset: 8; indent-tabs-mode: nil; -*-
   2  * vim:expandtab:shiftwidth=8:tabstop=8:
   3  *
   4  * Modifications for Lustre
   5  * Copyright 2004 - 2006, Cluster File Systems, Inc.
   6  * All rights reserved
   7  * Author: Eric Mei <ericm@clusterfs.com>
   8  */
   9
  10 /*
  11  *  linux/net/sunrpc/gss_krb5_mech.c
  12  *  linux/net/sunrpc/gss_krb5_crypto.c
  13  *  linux/net/sunrpc/gss_krb5_seal.c
  14  *  linux/net/sunrpc/gss_krb5_seqnum.c
  15  *  linux/net/sunrpc/gss_krb5_unseal.c
  16  *
  17  *  Copyright (c) 2001 The Regents of the University of Michigan.
  18  *  All rights reserved.
  19  *
  20  *  Andy Adamson <andros@umich.edu>
  21  *  J. Bruce Fields <bfields@umich.edu>
  22  *
  23  *  Redistribution and use in source and binary forms, with or without
  24  *  modification, are permitted provided that the following conditions
  25  *  are met:
  26  *
  27  *  1. Redistributions of source code must retain the above copyright
  28  *     notice, this list of conditions and the following disclaimer.
  29  *  2. Redistributions in binary form must reproduce the above copyright
  30  *     notice, this list of conditions and the following disclaimer in the
  31  *     documentation and/or other materials provided with the distribution.
  32  *  3. Neither the name of the University nor the names of its
  33  *     contributors may be used to endorse or promote products derived
  34  *     from this software without specific prior written permission.
  35  *
  36  *  THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED
  37  *  WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
  38  *  MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  39  *  DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  40  *  FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  41  *  CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  42  *  SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
  43  *  BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
  44  *  LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
  45  *  NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
  46  *  SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  47  *
  48  */
  49
  50 #ifndef EXPORT_SYMTAB
  51 # define EXPORT_SYMTAB
  52 #endif
  53 #define DEBUG_SUBSYSTEM S_SEC
  54 #ifdef __KERNEL__
  55 #include <linux/init.h>
  56 #include <linux/module.h>
  57 #include <linux/slab.h>
  58 #include <linux/crypto.h>
  59 #include <linux/random.h>
  60 #include <linux/mutex.h>
  61 #else
  62 #include <liblustre.h>
  63 #endif
  64
  65 #include <obd.h>
  66 #include <obd_class.h>
  67 #include <obd_support.h>
  68 #include <lustre/lustre_idl.h>
  69 #include <lustre_net.h>
  70 #include <lustre_import.h>
  71 #include <lustre_sec.h>
  72
  73 #include "gss_err.h"
  74 #include "gss_internal.h"
  75 #include "gss_api.h"
  76 #include "gss_asn1.h"
  77 #include "gss_krb5.h"
  78
  79 spinlock_t krb5_seq_lock = SPIN_LOCK_UNLOCKED;
  80
  81 struct krb5_enctype {
  82         char           *ke_dispname;
  83         char           *ke_enc_name;            /* linux tfm name */
  84         char           *ke_hash_name;           /* linux tfm name */
  85         int             ke_enc_mode;            /* linux tfm mode */
  86         int             ke_hash_size;           /* checksum size */
  87         int             ke_conf_size;           /* confounder size */
  88         unsigned int    ke_hash_hmac:1;         /* is hmac? */
  89 };
  90
  91 /*
  92  * NOTE: for aes128-cts and aes256-cts, MIT implementation use CTS encryption.
  93  * but currently we simply CBC with padding, because linux doesn't support CTS
  94  * yet. this need to be fixed in the future.
  95  */
  96 static struct krb5_enctype enctypes[] = {
  97         [ENCTYPE_DES_CBC_RAW] = {               /* des-cbc-md5 */
  98                 "des-cbc-md5",
  99                 "des",
 100                 "md5",
 101                 CRYPTO_TFM_MODE_CBC,
 102                 16,
 103                 8,
 104                 0,
 105         },
 106         [ENCTYPE_DES3_CBC_RAW] = {              /* des3-hmac-sha1 */
 107                 "des3-hmac-sha1",
 108                 "des3_ede",
 109                 "sha1",
 110                 CRYPTO_TFM_MODE_CBC,
 111                 20,
 112                 8,
 113                 1,
 114         },
 115         [ENCTYPE_AES128_CTS_HMAC_SHA1_96] = {   /* aes128-cts */
 116                 "aes128-cts-hmac-sha1-96",
 117                 "aes",
 118                 "sha1",
 119                 CRYPTO_TFM_MODE_CBC,
 120                 12,
 121                 16,
 122                 1,
 123         },
 124         [ENCTYPE_AES256_CTS_HMAC_SHA1_96] = {   /* aes256-cts */
 125                 "aes256-cts-hmac-sha1-96",
 126                 "aes",
 127                 "sha1",
 128                 CRYPTO_TFM_MODE_CBC,
 129                 12,
 130                 16,
 131                 1,
 132         },
 133         [ENCTYPE_ARCFOUR_HMAC] = {              /* arcfour-hmac-md5 */
 134                 "arcfour-hmac-md5",
 135                 "arc4",
 136                 "md5",
 137                 CRYPTO_TFM_MODE_ECB,
 138                 16,
 139                 8,
 140                 1,
 141         },
 142 };
 143
 144 #define MAX_ENCTYPES    sizeof(enctypes)/sizeof(struct krb5_enctype)
 145
 146 static const char * enctype2str(__u32 enctype)
 147 {
 148         if (enctype < MAX_ENCTYPES && enctypes[enctype].ke_dispname)
 149                 return enctypes[enctype].ke_dispname;
 150
 151         return "unknown";
 152 }
 153
 154 static
 155 int keyblock_init(struct krb5_keyblock *kb, char *alg_name, int alg_mode)
 156 {
 157         kb->kb_tfm = crypto_alloc_tfm(alg_name, alg_mode);
 158         if (kb->kb_tfm == NULL) {
 159                 CERROR("failed to alloc tfm: %s, mode %d\n",
 160                        alg_name, alg_mode);
 161                 return -1;
 162         }
 163
 164         if (crypto_cipher_setkey(kb->kb_tfm, kb->kb_key.data, kb->kb_key.len)) {
 165                 CERROR("failed to set %s key, len %d\n",
 166                        alg_name, kb->kb_key.len);
 167                 return -1;
 168         }
 169
 170         return 0;
 171 }
 172
 173 static
 174 int krb5_init_keys(struct krb5_ctx *kctx)
 175 {
 176         struct krb5_enctype *ke;
 177
 178         if (kctx->kc_enctype >= MAX_ENCTYPES ||
 179             enctypes[kctx->kc_enctype].ke_hash_size == 0) {
 180                 CERROR("unsupported enctype %x\n", kctx->kc_enctype);
 181                 return -1;
 182         }
 183
 184         ke = &enctypes[kctx->kc_enctype];
 185
 186         /* tfm arc4 is stateful, user should alloc-use-free by his own */
 187         if (kctx->kc_enctype != ENCTYPE_ARCFOUR_HMAC &&
 188             keyblock_init(&kctx->kc_keye, ke->ke_enc_name, ke->ke_enc_mode))
 189                 return -1;
 190
 191         /* tfm hmac is stateful, user should alloc-use-free by his own */
 192         if (ke->ke_hash_hmac == 0 &&
 193             keyblock_init(&kctx->kc_keyi, ke->ke_enc_name, ke->ke_enc_mode))
 194                 return -1;
 195         if (ke->ke_hash_hmac == 0 &&
 196             keyblock_init(&kctx->kc_keyc, ke->ke_enc_name, ke->ke_enc_mode))
 197                 return -1;
 198
 199         return 0;
 200 }
 201
 202 static
 203 void keyblock_free(struct krb5_keyblock *kb)
 204 {
 205         rawobj_free(&kb->kb_key);
 206         if (kb->kb_tfm)
 207                 crypto_free_tfm(kb->kb_tfm);
 208 }
 209
 210 static
 211 int keyblock_dup(struct krb5_keyblock *new, struct krb5_keyblock *kb)
 212 {
 213         return rawobj_dup(&new->kb_key, &kb->kb_key);
 214 }
 215
 216 static
 217 int get_bytes(char **ptr, const char *end, void *res, int len)
 218 {
 219         char *p, *q;
 220         p = *ptr;
 221         q = p + len;
 222         if (q > end || q < p)
 223                 return -1;
 224         memcpy(res, p, len);
 225         *ptr = q;
 226         return 0;
 227 }
 228
 229 static
 230 int get_rawobj(char **ptr, const char *end, rawobj_t *res)
 231 {
 232         char   *p, *q;
 233         __u32   len;
 234
 235         p = *ptr;
 236         if (get_bytes(&p, end, &len, sizeof(len)))
 237                 return -1;
 238
 239         q = p + len;
 240         if (q > end || q < p)
 241                 return -1;
 242
 243         OBD_ALLOC(res->data, len);
 244         if (!res->data)
 245                 return -1;
 246
 247         res->len = len;
 248         memcpy(res->data, p, len);
 249         *ptr = q;
 250         return 0;
 251 }
 252
 253 static
 254 int get_keyblock(char **ptr, const char *end,
 255                  struct krb5_keyblock *kb, __u32 keysize)
 256 {
 257         char *buf;
 258
 259         OBD_ALLOC(buf, keysize);
 260         if (buf == NULL)
 261                 return -1;
 262
 263         if (get_bytes(ptr, end, buf, keysize)) {
 264                 OBD_FREE(buf, keysize);
 265                 return -1;
 266         }
 267
 268         kb->kb_key.len = keysize;
 269         kb->kb_key.data = buf;
 270         return 0;
 271 }
 272
 273 static
 274 void delete_context_kerberos(struct krb5_ctx *kctx)
 275 {
 276         rawobj_free(&kctx->kc_mech_used);
 277
 278         keyblock_free(&kctx->kc_keye);
 279         keyblock_free(&kctx->kc_keyi);
 280         keyblock_free(&kctx->kc_keyc);
 281 }
 282
 283 static
 284 __u32 import_context_rfc1964(struct krb5_ctx *kctx, char *p, char *end)
 285 {
 286         unsigned int    tmp_uint, keysize;
 287
 288         /* seed_init flag */
 289         if (get_bytes(&p, end, &tmp_uint, sizeof(tmp_uint)))
 290                 goto out_err;
 291         kctx->kc_seed_init = (tmp_uint != 0);
 292
 293         /* seed */
 294         if (get_bytes(&p, end, kctx->kc_seed, sizeof(kctx->kc_seed)))
 295                 goto out_err;
 296
 297         /* sign/seal algorithm, not really used now */
 298         if (get_bytes(&p, end, &tmp_uint, sizeof(tmp_uint)) ||
 299             get_bytes(&p, end, &tmp_uint, sizeof(tmp_uint)))
 300                 goto out_err;
 301
 302         /* end time */
 303         if (get_bytes(&p, end, &kctx->kc_endtime, sizeof(kctx->kc_endtime)))
 304                 goto out_err;
 305
 306         /* seq send */
 307         if (get_bytes(&p, end, &tmp_uint, sizeof(tmp_uint)))
 308                 goto out_err;
 309         kctx->kc_seq_send = tmp_uint;
 310
 311         /* mech oid */
 312         if (get_rawobj(&p, end, &kctx->kc_mech_used))
 313                 goto out_err;
 314
 315         /* old style enc/seq keys in format:
 316          *   - enctype (u32)
 317          *   - keysize (u32)
 318          *   - keydata
 319          * we decompose them to fit into the new context
 320          */
 321
 322         /* enc key */
 323         if (get_bytes(&p, end, &kctx->kc_enctype, sizeof(kctx->kc_enctype)))
 324                 goto out_err;
 325
 326         if (get_bytes(&p, end, &keysize, sizeof(keysize)))
 327                 goto out_err;
 328
 329         if (get_keyblock(&p, end, &kctx->kc_keye, keysize))
 330                 goto out_err;
 331
 332         /* seq key */
 333         if (get_bytes(&p, end, &tmp_uint, sizeof(tmp_uint)) ||
 334             tmp_uint != kctx->kc_enctype)
 335                 goto out_err;
 336
 337         if (get_bytes(&p, end, &tmp_uint, sizeof(tmp_uint)) ||
 338             tmp_uint != keysize)
 339                 goto out_err;
 340
 341         if (get_keyblock(&p, end, &kctx->kc_keyc, keysize))
 342                 goto out_err;
 343
 344         /* old style fallback */
 345         if (keyblock_dup(&kctx->kc_keyi, &kctx->kc_keyc))
 346                 goto out_err;
 347
 348         if (p != end)
 349                 goto out_err;
 350
 351         CDEBUG(D_SEC, "succesfully imported rfc1964 context\n");
 352         return 0;
 353 out_err:
 354         return GSS_S_FAILURE;
 355 }
 356
 357 /* Flags for version 2 context flags */
 358 #define KRB5_CTX_FLAG_INITIATOR         0x00000001
 359 #define KRB5_CTX_FLAG_CFX               0x00000002
 360 #define KRB5_CTX_FLAG_ACCEPTOR_SUBKEY   0x00000004
 361
 362 static
 363 __u32 import_context_rfc4121(struct krb5_ctx *kctx, char *p, char *end)
 364 {
 365         unsigned int    tmp_uint, keysize;
 366
 367         /* end time */
 368         if (get_bytes(&p, end, &kctx->kc_endtime, sizeof(kctx->kc_endtime)))
 369                 goto out_err;
 370
 371         /* flags */
 372         if (get_bytes(&p, end, &tmp_uint, sizeof(tmp_uint)))
 373                 goto out_err;
 374
 375         if (tmp_uint & KRB5_CTX_FLAG_INITIATOR)
 376                 kctx->kc_initiate = 1;
 377         if (tmp_uint & KRB5_CTX_FLAG_CFX)
 378                 kctx->kc_cfx = 1;
 379         if (tmp_uint & KRB5_CTX_FLAG_ACCEPTOR_SUBKEY)
 380                 kctx->kc_have_acceptor_subkey = 1;
 381
 382         /* seq send */
 383         if (get_bytes(&p, end, &kctx->kc_seq_send, sizeof(kctx->kc_seq_send)))
 384                 goto out_err;
 385
 386         /* enctype */
 387         if (get_bytes(&p, end, &kctx->kc_enctype, sizeof(kctx->kc_enctype)))
 388                 goto out_err;
 389
 390         /* size of each key */
 391         if (get_bytes(&p, end, &keysize, sizeof(keysize)))
 392                 goto out_err;
 393
 394         /* number of keys - should always be 3 */
 395         if (get_bytes(&p, end, &tmp_uint, sizeof(tmp_uint)))
 396                 goto out_err;
 397
 398         if (tmp_uint != 3) {
 399                 CERROR("Invalid number of keys: %u\n", tmp_uint);
 400                 goto out_err;
 401         }
 402
 403         /* ke */
 404         if (get_keyblock(&p, end, &kctx->kc_keye, keysize))
 405                 goto out_err;
 406         /* ki */
 407         if (get_keyblock(&p, end, &kctx->kc_keyi, keysize))
 408                 goto out_err;
 409         /* ki */
 410         if (get_keyblock(&p, end, &kctx->kc_keyc, keysize))
 411                 goto out_err;
 412
 413         CDEBUG(D_SEC, "succesfully imported v2 context\n");
 414         return 0;
 415 out_err:
 416         return GSS_S_FAILURE;
 417 }
 418
 419 /*
 420  * The whole purpose here is trying to keep user level gss context parsing
 421  * from nfs-utils unchanged as possible as we can, they are not quite mature
 422  * yet, and many stuff still not clear, like heimdal etc.
 423  */
 424 static
 425 __u32 gss_import_sec_context_kerberos(rawobj_t *inbuf,
 426                                       struct gss_ctx *gctx)
 427 {
 428         struct krb5_ctx *kctx;
 429         char            *p = (char *) inbuf->data;
 430         char            *end = (char *) (inbuf->data + inbuf->len);
 431         unsigned int     tmp_uint, rc;
 432
 433         if (get_bytes(&p, end, &tmp_uint, sizeof(tmp_uint))) {
 434                 CERROR("Fail to read version\n");
 435                 return GSS_S_FAILURE;
 436         }
 437
 438         /* only support 0, 1 for the moment */
 439         if (tmp_uint > 2) {
 440                 CERROR("Invalid version %u\n", tmp_uint);
 441                 return GSS_S_FAILURE;
 442         }
 443
 444         OBD_ALLOC_PTR(kctx);
 445         if (!kctx)
 446                 return GSS_S_FAILURE;
 447
 448         if (tmp_uint == 0 || tmp_uint == 1) {
 449                 kctx->kc_initiate = tmp_uint;
 450                 rc = import_context_rfc1964(kctx, p, end);
 451         } else {
 452                 rc = import_context_rfc4121(kctx, p, end);
 453         }
 454
 455         if (rc == 0)
 456                 rc = krb5_init_keys(kctx);
 457
 458         if (rc) {
 459                 delete_context_kerberos(kctx);
 460                 OBD_FREE_PTR(kctx);
 461
 462                 return GSS_S_FAILURE;
 463         }
 464
 465         gctx->internal_ctx_id = kctx;
 466         return GSS_S_COMPLETE;
 467 }
 468
 469 static
 470 __u32 gss_copy_reverse_context_kerberos(struct gss_ctx *gctx,
 471                                         struct gss_ctx *gctx_new)
 472 {
 473         struct krb5_ctx *kctx = gctx->internal_ctx_id;
 474         struct krb5_ctx *knew;
 475
 476         OBD_ALLOC_PTR(knew);
 477         if (!knew)
 478                 return GSS_S_FAILURE;
 479
 480         knew->kc_initiate = kctx->kc_initiate ? 0 : 1;
 481         knew->kc_cfx = kctx->kc_cfx;
 482         knew->kc_seed_init = kctx->kc_seed_init;
 483         knew->kc_have_acceptor_subkey = kctx->kc_have_acceptor_subkey;
 484 #if 0
 485         knew->kc_endtime = kctx->kc_endtime;
 486 #else
 487         /* FIXME reverse context don't expire for now */
 488         knew->kc_endtime = INT_MAX;
 489 #endif
 490         memcpy(knew->kc_seed, kctx->kc_seed, sizeof(kctx->kc_seed));
 491         knew->kc_seq_send = kctx->kc_seq_recv;
 492         knew->kc_seq_recv = kctx->kc_seq_send;
 493         knew->kc_enctype = kctx->kc_enctype;
 494
 495         if (rawobj_dup(&knew->kc_mech_used, &kctx->kc_mech_used))
 496                 goto out_err;
 497
 498         if (keyblock_dup(&knew->kc_keye, &kctx->kc_keye))
 499                 goto out_err;
 500         if (keyblock_dup(&knew->kc_keyi, &kctx->kc_keyi))
 501                 goto out_err;
 502         if (keyblock_dup(&knew->kc_keyc, &kctx->kc_keyc))
 503                 goto out_err;
 504         if (krb5_init_keys(knew))
 505                 goto out_err;
 506
 507         gctx_new->internal_ctx_id = knew;
 508         CDEBUG(D_SEC, "succesfully copied reverse context\n");
 509         return GSS_S_COMPLETE;
 510
 511 out_err:
 512         delete_context_kerberos(knew);
 513         OBD_FREE_PTR(knew);
 514         return GSS_S_FAILURE;
 515 }
 516
 517 static
 518 __u32 gss_inquire_context_kerberos(struct gss_ctx *gctx,
 519                                    unsigned long  *endtime)
 520 {
 521         struct krb5_ctx *kctx = gctx->internal_ctx_id;
 522
 523         *endtime = (unsigned long) ((__u32) kctx->kc_endtime);
 524         return GSS_S_COMPLETE;
 525 }
 526
 527 static
 528 void gss_delete_sec_context_kerberos(void *internal_ctx)
 529 {
 530         struct krb5_ctx *kctx = internal_ctx;
 531
 532         delete_context_kerberos(kctx);
 533         OBD_FREE_PTR(kctx);
 534 }
 535
 536 static
 537 void buf_to_sg(struct scatterlist *sg, char *ptr, int len)
 538 {
 539         sg->page = virt_to_page(ptr);
 540         sg->offset = offset_in_page(ptr);
 541         sg->length = len;
 542 }
 543
 544 static
 545 __u32 krb5_encrypt(struct crypto_tfm *tfm,
 546                    int decrypt,
 547                    void * iv,
 548                    void * in,
 549                    void * out,
 550                    int length)
 551 {
 552         struct scatterlist sg;
 553         __u8 local_iv[16] = {0};
 554         __u32 ret = -EINVAL;
 555
 556         LASSERT(tfm);
 557
 558         if (length % crypto_tfm_alg_blocksize(tfm) != 0) {
 559                 CERROR("output length %d mismatch blocksize %d\n",
 560                        length, crypto_tfm_alg_blocksize(tfm));
 561                 goto out;
 562         }
 563
 564         if (crypto_tfm_alg_ivsize(tfm) > 16) {
 565                 CERROR("iv size too large %d\n", crypto_tfm_alg_ivsize(tfm));
 566                 goto out;
 567         }
 568
 569         if (iv)
 570                 memcpy(local_iv, iv, crypto_tfm_alg_ivsize(tfm));
 571
 572         memcpy(out, in, length);
 573         buf_to_sg(&sg, out, length);
 574
 575         if (decrypt)
 576                 ret = crypto_cipher_decrypt_iv(tfm, &sg, &sg, length, local_iv);
 577         else
 578                 ret = crypto_cipher_encrypt_iv(tfm, &sg, &sg, length, local_iv);
 579
 580 out:
 581         return(ret);
 582 }
 583
 584 static inline
 585 int krb5_digest_hmac(struct crypto_tfm *tfm,
 586                      rawobj_t *key,
 587                      struct krb5_header *khdr,
 588                      int msgcnt, rawobj_t *msgs,
 589                      rawobj_t *cksum)
 590 {
 591         struct scatterlist sg[1];
 592         __u32              keylen = key->len, i;
 593
 594         crypto_hmac_init(tfm, key->data, &keylen);
 595
 596         for (i = 0; i < msgcnt; i++) {
 597                 if (msgs[i].len == 0)
 598                         continue;
 599                 buf_to_sg(sg, (char *) msgs[i].data, msgs[i].len);
 600                 crypto_hmac_update(tfm, sg, 1);
 601         }
 602
 603         if (khdr) {
 604                 buf_to_sg(sg, (char *) khdr, sizeof(*khdr));
 605                 crypto_hmac_update(tfm, sg, 1);
 606         }
 607
 608         crypto_hmac_final(tfm, key->data, &keylen, cksum->data);
 609         return 0;
 610 }
 611
 612 static inline
 613 int krb5_digest_norm(struct crypto_tfm *tfm,
 614                      struct krb5_keyblock *kb,
 615                      struct krb5_header *khdr,
 616                      int msgcnt, rawobj_t *msgs,
 617                      rawobj_t *cksum)
 618 {
 619         struct scatterlist sg[1];
 620         int                i;
 621
 622         LASSERT(kb->kb_tfm);
 623
 624         crypto_digest_init(tfm);
 625
 626         for (i = 0; i < msgcnt; i++) {
 627                 if (msgs[i].len == 0)
 628                         continue;
 629                 buf_to_sg(sg, (char *) msgs[i].data, msgs[i].len);
 630                 crypto_digest_update(tfm, sg, 1);
 631         }
 632
 633         if (khdr) {
 634                 buf_to_sg(sg, (char *) khdr, sizeof(*khdr));
 635                 crypto_digest_update(tfm, sg, 1);
 636         }
 637
 638         crypto_digest_final(tfm, cksum->data);
 639
 640         return krb5_encrypt(kb->kb_tfm, 0, NULL, cksum->data,
 641                             cksum->data, cksum->len);
 642 }
 643
 644 /*
 645  * compute (keyed/keyless) checksum against the plain text which appended
 646  * with krb5 wire token header.
 647  */
 648 static
 649 __s32 krb5_make_checksum(__u32 enctype,
 650                          struct krb5_keyblock *kb,
 651                          struct krb5_header *khdr,
 652                          int msgcnt, rawobj_t *msgs,
 653                          rawobj_t *cksum)
 654 {
 655         struct krb5_enctype *ke = &enctypes[enctype];
 656         struct crypto_tfm   *tfm;
 657         __u32                code = GSS_S_FAILURE;
 658         int                  rc;
 659
 660         if (!(tfm = crypto_alloc_tfm(ke->ke_hash_name, 0))) {
 661                 CERROR("failed to alloc TFM: %s\n", ke->ke_hash_name);
 662                 return GSS_S_FAILURE;
 663         }
 664
 665         cksum->len = crypto_tfm_alg_digestsize(tfm);
 666         OBD_ALLOC(cksum->data, cksum->len);
 667         if (!cksum->data) {
 668                 cksum->len = 0;
 669                 goto out_tfm;
 670         }
 671
 672         if (ke->ke_hash_hmac)
 673                 rc = krb5_digest_hmac(tfm, &kb->kb_key,
 674                                       khdr, msgcnt, msgs, cksum);
 675         else
 676                 rc = krb5_digest_norm(tfm, kb,
 677                                       khdr, msgcnt, msgs, cksum);
 678
 679         if (rc == 0)
 680                 code = GSS_S_COMPLETE;
 681 out_tfm:
 682         crypto_free_tfm(tfm);
 683         return code;
 684 }
 685
 686 static
 687 __u32 gss_get_mic_kerberos(struct gss_ctx *gctx,
 688                            int msgcnt,
 689                            rawobj_t *msgs,
 690                            rawobj_t *token)
 691 {
 692         struct krb5_ctx     *kctx = gctx->internal_ctx_id;
 693         struct krb5_enctype *ke = &enctypes[kctx->kc_enctype];
 694         struct krb5_header  *khdr;
 695         unsigned char        acceptor_flag;
 696         rawobj_t             cksum = RAWOBJ_EMPTY;
 697         __u32                rc = GSS_S_FAILURE;
 698
 699         acceptor_flag = kctx->kc_initiate ? 0 : FLAG_SENDER_IS_ACCEPTOR;
 700
 701         /* fill krb5 header */
 702         LASSERT(token->len >= sizeof(*khdr));
 703         khdr = (struct krb5_header *) token->data;
 704
 705         khdr->kh_tok_id = cpu_to_be16(KG_TOK_MIC_MSG);
 706         khdr->kh_flags = acceptor_flag;
 707         khdr->kh_filler = 0xff;
 708         khdr->kh_ec = cpu_to_be16(0xffff);
 709         khdr->kh_rrc = cpu_to_be16(0xffff);
 710         spin_lock(&krb5_seq_lock);
 711         khdr->kh_seq = cpu_to_be64(kctx->kc_seq_send++);
 712         spin_unlock(&krb5_seq_lock);
 713
 714         /* checksum */
 715         if (krb5_make_checksum(kctx->kc_enctype, &kctx->kc_keyc,
 716                                khdr, msgcnt, msgs, &cksum))
 717                 goto out_err;
 718
 719         LASSERT(cksum.len >= ke->ke_hash_size);
 720         LASSERT(token->len >= sizeof(*khdr) + ke->ke_hash_size);
 721         memcpy(khdr + 1, cksum.data + cksum.len - ke->ke_hash_size,
 722                ke->ke_hash_size);
 723
 724         token->len = sizeof(*khdr) + ke->ke_hash_size;
 725         rc = GSS_S_COMPLETE;
 726 out_err:
 727         rawobj_free(&cksum);
 728         return rc;
 729 }
 730
 731 static
 732 __u32 gss_verify_mic_kerberos(struct gss_ctx *gctx,
 733                               int msgcnt,
 734                               rawobj_t *msgs,
 735                               rawobj_t *token)
 736 {
 737         struct krb5_ctx     *kctx = gctx->internal_ctx_id;
 738         struct krb5_enctype *ke = &enctypes[kctx->kc_enctype];
 739         struct krb5_header  *khdr;
 740         unsigned char        acceptor_flag;
 741         rawobj_t             cksum = RAWOBJ_EMPTY;
 742         __u32                rc = GSS_S_FAILURE;
 743
 744         acceptor_flag = kctx->kc_initiate ? FLAG_SENDER_IS_ACCEPTOR : 0;
 745
 746         if (token->len < sizeof(*khdr)) {
 747                 CERROR("short signature: %u\n", token->len);
 748                 return GSS_S_DEFECTIVE_TOKEN;
 749         }
 750
 751         khdr = (struct krb5_header *) token->data;
 752
 753         /* sanity checks */
 754         if (be16_to_cpu(khdr->kh_tok_id) != KG_TOK_MIC_MSG) {
 755                 CERROR("bad token id\n");
 756                 return GSS_S_DEFECTIVE_TOKEN;
 757         }
 758         if ((khdr->kh_flags & FLAG_SENDER_IS_ACCEPTOR) != acceptor_flag) {
 759                 CERROR("bad direction flag\n");
 760                 return GSS_S_BAD_SIG;
 761         }
 762         if (khdr->kh_filler != 0xff) {
 763                 CERROR("bad filler\n");
 764                 return GSS_S_DEFECTIVE_TOKEN;
 765         }
 766         if (be16_to_cpu(khdr->kh_ec) != 0xffff ||
 767             be16_to_cpu(khdr->kh_rrc) != 0xffff) {
 768                 CERROR("bad EC or RRC\n");
 769                 return GSS_S_DEFECTIVE_TOKEN;
 770         }
 771
 772         if (token->len < sizeof(*khdr) + ke->ke_hash_size) {
 773                 CERROR("short signature: %u, require %d\n",
 774                        token->len, (int) sizeof(*khdr) + ke->ke_hash_size);
 775                 goto out;
 776         }
 777
 778         if (krb5_make_checksum(kctx->kc_enctype, &kctx->kc_keyc,
 779                                khdr, msgcnt, msgs, &cksum))
 780                 return GSS_S_FAILURE;
 781
 782         LASSERT(cksum.len >= ke->ke_hash_size);
 783         if (memcmp(khdr + 1, cksum.data + cksum.len - ke->ke_hash_size,
 784                    ke->ke_hash_size)) {
 785                 CERROR("checksum mismatch\n");
 786                 rc = GSS_S_BAD_SIG;
 787                 goto out;
 788         }
 789
 790         rc = GSS_S_COMPLETE;
 791 out:
 792         rawobj_free(&cksum);
 793         return rc;
 794 }
 795
 796 static
 797 int add_padding(rawobj_t *msg, int msg_buflen, int blocksize)
 798 {
 799         int padding;
 800
 801         padding = (blocksize - (msg->len & (blocksize - 1))) &
 802                   (blocksize - 1);
 803         if (!padding)
 804                 return 0;
 805
 806         if (msg->len + padding > msg_buflen) {
 807                 CERROR("bufsize %u too small: datalen %u, padding %u\n",
 808                         msg_buflen, msg->len, padding);
 809                 return -EINVAL;
 810         }
 811
 812         memset(msg->data + msg->len, padding, padding);
 813         msg->len += padding;
 814         return 0;
 815 }
 816
 817 static
 818 int krb5_encrypt_rawobjs(struct crypto_tfm *tfm,
 819                          int mode_ecb,
 820                          int inobj_cnt,
 821                          rawobj_t *inobjs,
 822                          rawobj_t *outobj,
 823                          int enc)
 824 {
 825         struct scatterlist src, dst;
 826         __u8               local_iv[16] = {0}, *buf;
 827         __u32              datalen = 0;
 828         int                i, rc;
 829         ENTRY;
 830
 831         buf = outobj->data;
 832
 833         for (i = 0; i < inobj_cnt; i++) {
 834                 LASSERT(buf + inobjs[i].len <= outobj->data + outobj->len);
 835
 836                 buf_to_sg(&src, inobjs[i].data, inobjs[i].len);
 837                 buf_to_sg(&dst, buf, outobj->len - datalen);
 838
 839                 if (mode_ecb) {
 840                         if (enc)
 841                                 rc = crypto_cipher_encrypt(
 842                                         tfm, &dst, &src, src.length);
 843                         else
 844                                 rc = crypto_cipher_decrypt(
 845                                         tfm, &dst, &src, src.length);
 846                 } else {
 847                         if (enc)
 848                                 rc = crypto_cipher_encrypt_iv(
 849                                         tfm, &dst, &src, src.length, local_iv);
 850                         else
 851                                 rc = crypto_cipher_decrypt_iv(
 852                                         tfm, &dst, &src, src.length, local_iv);
 853                 }
 854
 855                 if (rc) {
 856                         CERROR("encrypt error %d\n", rc);
 857                         RETURN(rc);
 858                 }
 859
 860                 datalen += inobjs[i].len;
 861                 buf += inobjs[i].len;
 862         }
 863
 864         outobj->len = datalen;
 865         RETURN(0);
 866 }
 867
 868 static
 869 __u32 gss_wrap_kerberos(struct gss_ctx *gctx,
 870                         rawobj_t *msg,
 871                         int msg_buflen,
 872                         rawobj_t *token)
 873 {
 874         struct krb5_ctx     *kctx = gctx->internal_ctx_id;
 875         struct krb5_enctype *ke = &enctypes[kctx->kc_enctype];
 876         struct krb5_header  *khdr;
 877         unsigned char        acceptor_flag;
 878         int                  blocksize;
 879         rawobj_t             cksum = RAWOBJ_EMPTY;
 880         rawobj_t             data_desc[3], cipher;
 881         __u8                 conf[GSS_MAX_CIPHER_BLOCK];
 882         int                  enc_rc = 0;
 883
 884         LASSERT(ke);
 885         LASSERT(ke->ke_conf_size <= GSS_MAX_CIPHER_BLOCK);
 886         LASSERT(kctx->kc_keye.kb_tfm == NULL ||
 887                 ke->ke_conf_size >=
 888                 crypto_tfm_alg_blocksize(kctx->kc_keye.kb_tfm));
 889
 890         acceptor_flag = kctx->kc_initiate ? 0 : FLAG_SENDER_IS_ACCEPTOR;
 891
 892         /* fill krb5 header */
 893         LASSERT(token->len >= sizeof(*khdr));
 894         khdr = (struct krb5_header *) token->data;
 895
 896         khdr->kh_tok_id = cpu_to_be16(KG_TOK_WRAP_MSG);
 897         khdr->kh_flags = acceptor_flag | FLAG_WRAP_CONFIDENTIAL;
 898         khdr->kh_filler = 0xff;
 899         khdr->kh_ec = cpu_to_be16(0);
 900         khdr->kh_rrc = cpu_to_be16(0);
 901         spin_lock(&krb5_seq_lock);
 902         khdr->kh_seq = cpu_to_be64(kctx->kc_seq_send++);
 903         spin_unlock(&krb5_seq_lock);
 904
 905         /* generate confounder */
 906         get_random_bytes(conf, ke->ke_conf_size);
 907
 908         /* get encryption blocksize. note kc_keye might not associated with
 909          * a tfm, currently only for arcfour-hmac
 910          */
 911         if (kctx->kc_enctype == ENCTYPE_ARCFOUR_HMAC) {
 912                 LASSERT(kctx->kc_keye.kb_tfm == NULL);
 913                 blocksize = 1;
 914         } else {
 915                 LASSERT(kctx->kc_keye.kb_tfm);
 916                 blocksize = crypto_tfm_alg_blocksize(kctx->kc_keye.kb_tfm);
 917         }
 918         LASSERT(blocksize <= ke->ke_conf_size);
 919
 920         /* padding the message */
 921         if (add_padding(msg, msg_buflen, blocksize))
 922                 return GSS_S_FAILURE;
 923
 924         /*
 925          * clear text layout, same for both checksum & encryption:
 926          * -----------------------------------------
 927          * | confounder | clear msgs | krb5 header |
 928          * -----------------------------------------
 929          */
 930         data_desc[0].data = conf;
 931         data_desc[0].len = ke->ke_conf_size;
 932         data_desc[1].data = msg->data;
 933         data_desc[1].len = msg->len;
 934         data_desc[2].data = (__u8 *) khdr;
 935         data_desc[2].len = sizeof(*khdr);
 936
 937         /* compute checksum */
 938         if (krb5_make_checksum(kctx->kc_enctype, &kctx->kc_keyi,
 939                                khdr, 3, data_desc, &cksum))
 940                 return GSS_S_FAILURE;
 941         LASSERT(cksum.len >= ke->ke_hash_size);
 942
 943         /* encrypting, cipher text will be directly inplace */
 944         cipher.data = (__u8 *) (khdr + 1);
 945         cipher.len = token->len - sizeof(*khdr);
 946         LASSERT(cipher.len >= ke->ke_conf_size + msg->len + sizeof(*khdr));
 947
 948         if (kctx->kc_enctype == ENCTYPE_ARCFOUR_HMAC) {
 949                 rawobj_t                arc4_keye;
 950                 struct crypto_tfm      *arc4_tfm;
 951
 952                 if (krb5_make_checksum(ENCTYPE_ARCFOUR_HMAC, &kctx->kc_keyi,
 953                                        NULL, 1, &cksum, &arc4_keye)) {
 954                         CERROR("failed to obtain arc4 enc key\n");
 955                         GOTO(arc4_out, enc_rc = -EACCES);
 956                 }
 957
 958                 arc4_tfm = crypto_alloc_tfm("arc4", CRYPTO_TFM_MODE_ECB);
 959                 if (arc4_tfm == NULL) {
 960                         CERROR("failed to alloc tfm arc4 in ECB mode\n");
 961                         GOTO(arc4_out_key, enc_rc = -EACCES);
 962                 }
 963
 964                 if (crypto_cipher_setkey(arc4_tfm,
 965                                          arc4_keye.data, arc4_keye.len)) {
 966                         CERROR("failed to set arc4 key, len %d\n",
 967                                arc4_keye.len);
 968                         GOTO(arc4_out_tfm, enc_rc = -EACCES);
 969                 }
 970
 971                 enc_rc = krb5_encrypt_rawobjs(arc4_tfm, 1,
 972                                               3, data_desc, &cipher, 1);
 973 arc4_out_tfm:
 974                 crypto_free_tfm(arc4_tfm);
 975 arc4_out_key:
 976                 rawobj_free(&arc4_keye);
 977 arc4_out:
 978                 do {} while(0); /* just to avoid compile warning */
 979         } else {
 980                 enc_rc = krb5_encrypt_rawobjs(kctx->kc_keye.kb_tfm, 0,
 981                                               3, data_desc, &cipher, 1);
 982         }
 983
 984         if (enc_rc != 0) {
 985                 rawobj_free(&cksum);
 986                 return GSS_S_FAILURE;
 987         }
 988
 989         /* fill in checksum */
 990         LASSERT(token->len >= sizeof(*khdr) + cipher.len + ke->ke_hash_size);
 991         memcpy((char *)(khdr + 1) + cipher.len,
 992                cksum.data + cksum.len - ke->ke_hash_size,
 993                ke->ke_hash_size);
 994         rawobj_free(&cksum);
 995
 996         /* final token length */
 997         token->len = sizeof(*khdr) + cipher.len + ke->ke_hash_size;
 998         return GSS_S_COMPLETE;
 999 }
1000
1001 static
1002 __u32 gss_unwrap_kerberos(struct gss_ctx  *gctx,
1003                           rawobj_t        *token,
1004                           rawobj_t        *msg)
1005 {
1006         struct krb5_ctx     *kctx = gctx->internal_ctx_id;
1007         struct krb5_enctype *ke = &enctypes[kctx->kc_enctype];
1008         struct krb5_header  *khdr;
1009         unsigned char        acceptor_flag;
1010         unsigned char       *tmpbuf;
1011         int                  blocksize, bodysize;
1012         rawobj_t             cksum = RAWOBJ_EMPTY;
1013         rawobj_t             cipher_in, plain_out;
1014         __u32                rc = GSS_S_FAILURE, enc_rc = 0;
1015
1016         LASSERT(ke);
1017
1018         acceptor_flag = kctx->kc_initiate ? FLAG_SENDER_IS_ACCEPTOR : 0;
1019
1020         if (token->len < sizeof(*khdr)) {
1021                 CERROR("short signature: %u\n", token->len);
1022                 return GSS_S_DEFECTIVE_TOKEN;
1023         }
1024
1025         khdr = (struct krb5_header *) token->data;
1026
1027         /* sanity check header */
1028         if (be16_to_cpu(khdr->kh_tok_id) != KG_TOK_WRAP_MSG) {
1029                 CERROR("bad token id\n");
1030                 return GSS_S_DEFECTIVE_TOKEN;
1031         }
1032         if ((khdr->kh_flags & FLAG_SENDER_IS_ACCEPTOR) != acceptor_flag) {
1033                 CERROR("bad direction flag\n");
1034                 return GSS_S_BAD_SIG;
1035         }
1036         if ((khdr->kh_flags & FLAG_WRAP_CONFIDENTIAL) == 0) {
1037                 CERROR("missing confidential flag\n");
1038                 return GSS_S_BAD_SIG;
1039         }
1040         if (khdr->kh_filler != 0xff) {
1041                 CERROR("bad filler\n");
1042                 return GSS_S_DEFECTIVE_TOKEN;
1043         }
1044         if (be16_to_cpu(khdr->kh_ec) != 0x0 ||
1045             be16_to_cpu(khdr->kh_rrc) != 0x0) {
1046                 CERROR("bad EC or RRC\n");
1047                 return GSS_S_DEFECTIVE_TOKEN;
1048         }
1049
1050         /* block size */
1051         if (kctx->kc_enctype == ENCTYPE_ARCFOUR_HMAC) {
1052                 LASSERT(kctx->kc_keye.kb_tfm == NULL);
1053                 blocksize = 1;
1054         } else {
1055                 LASSERT(kctx->kc_keye.kb_tfm);
1056                 blocksize = crypto_tfm_alg_blocksize(kctx->kc_keye.kb_tfm);
1057         }
1058
1059         /* expected token layout:
1060          * ----------------------------------------
1061          * | krb5 header | cipher text | checksum |
1062          * ----------------------------------------
1063          */
1064         bodysize = token->len - sizeof(*khdr) - ke->ke_hash_size;
1065
1066         if (bodysize % blocksize) {
1067                 CERROR("odd bodysize %d\n", bodysize);
1068                 return GSS_S_DEFECTIVE_TOKEN;
1069         }
1070
1071         if (bodysize <= ke->ke_conf_size + sizeof(*khdr)) {
1072                 CERROR("incomplete token: bodysize %d\n", bodysize);
1073                 return GSS_S_DEFECTIVE_TOKEN;
1074         }
1075
1076         if (msg->len < bodysize - ke->ke_conf_size - sizeof(*khdr)) {
1077                 CERROR("buffer too small: %u, require %d\n",
1078                        msg->len, bodysize - ke->ke_conf_size);
1079                 return GSS_S_FAILURE;
1080         }
1081
1082         /* decrypting */
1083         OBD_ALLOC(tmpbuf, bodysize);
1084         if (!tmpbuf)
1085                 return GSS_S_FAILURE;
1086
1087         cipher_in.data = (__u8 *) (khdr + 1);
1088         cipher_in.len = bodysize;
1089         plain_out.data = tmpbuf;
1090         plain_out.len = bodysize;
1091
1092         if (kctx->kc_enctype == ENCTYPE_ARCFOUR_HMAC) {
1093                 rawobj_t                arc4_keye;
1094                 struct crypto_tfm      *arc4_tfm;
1095
1096                 cksum.data = token->data + token->len - ke->ke_hash_size;
1097                 cksum.len = ke->ke_hash_size;
1098
1099                 if (krb5_make_checksum(ENCTYPE_ARCFOUR_HMAC, &kctx->kc_keyi,
1100                                        NULL, 1, &cksum, &arc4_keye)) {
1101                         CERROR("failed to obtain arc4 enc key\n");
1102                         GOTO(arc4_out, enc_rc = -EACCES);
1103                 }
1104
1105                 arc4_tfm = crypto_alloc_tfm("arc4", CRYPTO_TFM_MODE_ECB);
1106                 if (arc4_tfm == NULL) {
1107                         CERROR("failed to alloc tfm arc4 in ECB mode\n");
1108                         GOTO(arc4_out_key, enc_rc = -EACCES);
1109                 }
1110
1111                 if (crypto_cipher_setkey(arc4_tfm,
1112                                          arc4_keye.data, arc4_keye.len)) {
1113                         CERROR("failed to set arc4 key, len %d\n",
1114                                arc4_keye.len);
1115                         GOTO(arc4_out_tfm, enc_rc = -EACCES);
1116                 }
1117
1118                 enc_rc = krb5_encrypt_rawobjs(arc4_tfm, 1,
1119                                               1, &cipher_in, &plain_out, 0);
1120 arc4_out_tfm:
1121                 crypto_free_tfm(arc4_tfm);
1122 arc4_out_key:
1123                 rawobj_free(&arc4_keye);
1124 arc4_out:
1125                 cksum = RAWOBJ_EMPTY;
1126         } else {
1127                 enc_rc = krb5_encrypt_rawobjs(kctx->kc_keye.kb_tfm, 0,
1128                                               1, &cipher_in, &plain_out, 0);
1129         }
1130
1131         if (enc_rc != 0) {
1132                 CERROR("error decrypt\n");
1133                 goto out_free;
1134         }
1135         LASSERT(plain_out.len == bodysize);
1136
1137         /* expected clear text layout:
1138          * -----------------------------------------
1139          * | confounder | clear msgs | krb5 header |
1140          * -----------------------------------------
1141          */
1142
1143         /* last part must be identical to the krb5 header */
1144         if (memcmp(khdr, plain_out.data + plain_out.len - sizeof(*khdr),
1145                    sizeof(*khdr))) {
1146                 CERROR("decrypted header mismatch\n");
1147                 goto out_free;
1148         }
1149
1150         /* verify checksum */
1151         if (krb5_make_checksum(kctx->kc_enctype, &kctx->kc_keyi,
1152                                khdr, 1, &plain_out, &cksum))
1153                 goto out_free;
1154
1155         LASSERT(cksum.len >= ke->ke_hash_size);
1156         if (memcmp((char *)(khdr + 1) + bodysize,
1157                    cksum.data + cksum.len - ke->ke_hash_size,
1158                    ke->ke_hash_size)) {
1159                 CERROR("cksum mismatch\n");
1160                 goto out_free;
1161         }
1162
1163         msg->len =  bodysize - ke->ke_conf_size - sizeof(*khdr);
1164         memcpy(msg->data, tmpbuf + ke->ke_conf_size, msg->len);
1165
1166         rc = GSS_S_COMPLETE;
1167 out_free:
1168         OBD_FREE(tmpbuf, bodysize);
1169         rawobj_free(&cksum);
1170         return rc;
1171 }
1172
1173 static
1174 __u32 gss_plain_encrypt_kerberos(struct gss_ctx  *ctx,
1175                                  int              length,
1176                                  void            *in_buf,
1177                                  void            *out_buf)
1178 {
1179         struct krb5_ctx        *kctx = ctx->internal_ctx_id;
1180         __u32                   rc;
1181
1182         rc = krb5_encrypt(kctx->kc_keye.kb_tfm, 0,
1183                           NULL, in_buf, out_buf, length);
1184         if (rc)
1185                 CERROR("plain encrypt error: %d\n", rc);
1186
1187         return rc;
1188 }
1189
1190 int gss_display_kerberos(struct gss_ctx        *ctx,
1191                          char                  *buf,
1192                          int                    bufsize)
1193 {
1194         struct krb5_ctx    *kctx = ctx->internal_ctx_id;
1195         int                 written;
1196
1197         written = snprintf(buf, bufsize,
1198                         "  mech:        krb5\n"
1199                         "  enctype:     %s\n",
1200                         enctype2str(kctx->kc_enctype));
1201         return written;
1202 }
1203
1204 static struct gss_api_ops gss_kerberos_ops = {
1205         .gss_import_sec_context     = gss_import_sec_context_kerberos,
1206         .gss_copy_reverse_context   = gss_copy_reverse_context_kerberos,
1207         .gss_inquire_context        = gss_inquire_context_kerberos,
1208         .gss_get_mic                = gss_get_mic_kerberos,
1209         .gss_verify_mic             = gss_verify_mic_kerberos,
1210         .gss_wrap                   = gss_wrap_kerberos,
1211         .gss_unwrap                 = gss_unwrap_kerberos,
1212         .gss_plain_encrypt          = gss_plain_encrypt_kerberos,
1213         .gss_delete_sec_context     = gss_delete_sec_context_kerberos,
1214         .gss_display                = gss_display_kerberos,
1215 };
1216
1217 static struct subflavor_desc gss_kerberos_sfs[] = {
1218         {
1219                 .sf_subflavor   = SPTLRPC_SUBFLVR_KRB5,
1220                 .sf_qop         = 0,
1221                 .sf_service     = SPTLRPC_SVC_NONE,
1222                 .sf_name        = "krb5"
1223         },
1224         {
1225                 .sf_subflavor   = SPTLRPC_SUBFLVR_KRB5I,
1226                 .sf_qop         = 0,
1227                 .sf_service     = SPTLRPC_SVC_AUTH,
1228                 .sf_name        = "krb5i"
1229         },
1230         {
1231                 .sf_subflavor   = SPTLRPC_SUBFLVR_KRB5P,
1232                 .sf_qop         = 0,
1233                 .sf_service     = SPTLRPC_SVC_PRIV,
1234                 .sf_name        = "krb5p"
1235         },
1236 };
1237
1238 /*
1239  * currently we leave module owner NULL
1240  */
1241 static struct gss_api_mech gss_kerberos_mech = {
1242         .gm_owner       = NULL, /*THIS_MODULE, */
1243         .gm_name        = "krb5",
1244         .gm_oid         = (rawobj_t)
1245                                 {9, "\052\206\110\206\367\022\001\002\002"},
1246         .gm_ops         = &gss_kerberos_ops,
1247         .gm_sf_num      = 3,
1248         .gm_sfs         = gss_kerberos_sfs,
1249 };
1250
1251 int __init init_kerberos_module(void)
1252 {
1253         int status;
1254
1255         status = lgss_mech_register(&gss_kerberos_mech);
1256         if (status)
1257                 CERROR("Failed to register kerberos gss mechanism!\n");
1258         return status;
1259 }
1260
1261 void __exit cleanup_kerberos_module(void)
1262 {
1263         lgss_mech_unregister(&gss_kerberos_mech);
1264 }