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         knew->kc_endtime = kctx->kc_endtime;
 485
 486         memcpy(knew->kc_seed, kctx->kc_seed, sizeof(kctx->kc_seed));
 487         knew->kc_seq_send = kctx->kc_seq_recv;
 488         knew->kc_seq_recv = kctx->kc_seq_send;
 489         knew->kc_enctype = kctx->kc_enctype;
 490
 491         if (rawobj_dup(&knew->kc_mech_used, &kctx->kc_mech_used))
 492                 goto out_err;
 493
 494         if (keyblock_dup(&knew->kc_keye, &kctx->kc_keye))
 495                 goto out_err;
 496         if (keyblock_dup(&knew->kc_keyi, &kctx->kc_keyi))
 497                 goto out_err;
 498         if (keyblock_dup(&knew->kc_keyc, &kctx->kc_keyc))
 499                 goto out_err;
 500         if (krb5_init_keys(knew))
 501                 goto out_err;
 502
 503         gctx_new->internal_ctx_id = knew;
 504         CDEBUG(D_SEC, "succesfully copied reverse context\n");
 505         return GSS_S_COMPLETE;
 506
 507 out_err:
 508         delete_context_kerberos(knew);
 509         OBD_FREE_PTR(knew);
 510         return GSS_S_FAILURE;
 511 }
 512
 513 static
 514 __u32 gss_inquire_context_kerberos(struct gss_ctx *gctx,
 515                                    unsigned long  *endtime)
 516 {
 517         struct krb5_ctx *kctx = gctx->internal_ctx_id;
 518
 519         *endtime = (unsigned long) ((__u32) kctx->kc_endtime);
 520         return GSS_S_COMPLETE;
 521 }
 522
 523 static
 524 void gss_delete_sec_context_kerberos(void *internal_ctx)
 525 {
 526         struct krb5_ctx *kctx = internal_ctx;
 527
 528         delete_context_kerberos(kctx);
 529         OBD_FREE_PTR(kctx);
 530 }
 531
 532 static
 533 void buf_to_sg(struct scatterlist *sg, char *ptr, int len)
 534 {
 535         sg->page = virt_to_page(ptr);
 536         sg->offset = offset_in_page(ptr);
 537         sg->length = len;
 538 }
 539
 540 static
 541 __u32 krb5_encrypt(struct crypto_tfm *tfm,
 542                    int decrypt,
 543                    void * iv,
 544                    void * in,
 545                    void * out,
 546                    int length)
 547 {
 548         struct scatterlist sg;
 549         __u8 local_iv[16] = {0};
 550         __u32 ret = -EINVAL;
 551
 552         LASSERT(tfm);
 553
 554         if (length % crypto_tfm_alg_blocksize(tfm) != 0) {
 555                 CERROR("output length %d mismatch blocksize %d\n",
 556                        length, crypto_tfm_alg_blocksize(tfm));
 557                 goto out;
 558         }
 559
 560         if (crypto_tfm_alg_ivsize(tfm) > 16) {
 561                 CERROR("iv size too large %d\n", crypto_tfm_alg_ivsize(tfm));
 562                 goto out;
 563         }
 564
 565         if (iv)
 566                 memcpy(local_iv, iv, crypto_tfm_alg_ivsize(tfm));
 567
 568         memcpy(out, in, length);
 569         buf_to_sg(&sg, out, length);
 570
 571         if (decrypt)
 572                 ret = crypto_cipher_decrypt_iv(tfm, &sg, &sg, length, local_iv);
 573         else
 574                 ret = crypto_cipher_encrypt_iv(tfm, &sg, &sg, length, local_iv);
 575
 576 out:
 577         return(ret);
 578 }
 579
 580 static inline
 581 int krb5_digest_hmac(struct crypto_tfm *tfm,
 582                      rawobj_t *key,
 583                      struct krb5_header *khdr,
 584                      int msgcnt, rawobj_t *msgs,
 585                      rawobj_t *cksum)
 586 {
 587         struct scatterlist sg[1];
 588         __u32              keylen = key->len, i;
 589
 590         crypto_hmac_init(tfm, key->data, &keylen);
 591
 592         for (i = 0; i < msgcnt; i++) {
 593                 if (msgs[i].len == 0)
 594                         continue;
 595                 buf_to_sg(sg, (char *) msgs[i].data, msgs[i].len);
 596                 crypto_hmac_update(tfm, sg, 1);
 597         }
 598
 599         if (khdr) {
 600                 buf_to_sg(sg, (char *) khdr, sizeof(*khdr));
 601                 crypto_hmac_update(tfm, sg, 1);
 602         }
 603
 604         crypto_hmac_final(tfm, key->data, &keylen, cksum->data);
 605         return 0;
 606 }
 607
 608 static inline
 609 int krb5_digest_norm(struct crypto_tfm *tfm,
 610                      struct krb5_keyblock *kb,
 611                      struct krb5_header *khdr,
 612                      int msgcnt, rawobj_t *msgs,
 613                      rawobj_t *cksum)
 614 {
 615         struct scatterlist sg[1];
 616         int                i;
 617
 618         LASSERT(kb->kb_tfm);
 619
 620         crypto_digest_init(tfm);
 621
 622         for (i = 0; i < msgcnt; i++) {
 623                 if (msgs[i].len == 0)
 624                         continue;
 625                 buf_to_sg(sg, (char *) msgs[i].data, msgs[i].len);
 626                 crypto_digest_update(tfm, sg, 1);
 627         }
 628
 629         if (khdr) {
 630                 buf_to_sg(sg, (char *) khdr, sizeof(*khdr));
 631                 crypto_digest_update(tfm, sg, 1);
 632         }
 633
 634         crypto_digest_final(tfm, cksum->data);
 635
 636         return krb5_encrypt(kb->kb_tfm, 0, NULL, cksum->data,
 637                             cksum->data, cksum->len);
 638 }
 639
 640 /*
 641  * compute (keyed/keyless) checksum against the plain text which appended
 642  * with krb5 wire token header.
 643  */
 644 static
 645 __s32 krb5_make_checksum(__u32 enctype,
 646                          struct krb5_keyblock *kb,
 647                          struct krb5_header *khdr,
 648                          int msgcnt, rawobj_t *msgs,
 649                          rawobj_t *cksum)
 650 {
 651         struct krb5_enctype *ke = &enctypes[enctype];
 652         struct crypto_tfm   *tfm;
 653         __u32                code = GSS_S_FAILURE;
 654         int                  rc;
 655
 656         if (!(tfm = crypto_alloc_tfm(ke->ke_hash_name, 0))) {
 657                 CERROR("failed to alloc TFM: %s\n", ke->ke_hash_name);
 658                 return GSS_S_FAILURE;
 659         }
 660
 661         cksum->len = crypto_tfm_alg_digestsize(tfm);
 662         OBD_ALLOC(cksum->data, cksum->len);
 663         if (!cksum->data) {
 664                 cksum->len = 0;
 665                 goto out_tfm;
 666         }
 667
 668         if (ke->ke_hash_hmac)
 669                 rc = krb5_digest_hmac(tfm, &kb->kb_key,
 670                                       khdr, msgcnt, msgs, cksum);
 671         else
 672                 rc = krb5_digest_norm(tfm, kb,
 673                                       khdr, msgcnt, msgs, cksum);
 674
 675         if (rc == 0)
 676                 code = GSS_S_COMPLETE;
 677 out_tfm:
 678         crypto_free_tfm(tfm);
 679         return code;
 680 }
 681
 682 static
 683 __u32 gss_get_mic_kerberos(struct gss_ctx *gctx,
 684                            int msgcnt,
 685                            rawobj_t *msgs,
 686                            rawobj_t *token)
 687 {
 688         struct krb5_ctx     *kctx = gctx->internal_ctx_id;
 689         struct krb5_enctype *ke = &enctypes[kctx->kc_enctype];
 690         struct krb5_header  *khdr;
 691         unsigned char        acceptor_flag;
 692         rawobj_t             cksum = RAWOBJ_EMPTY;
 693         __u32                rc = GSS_S_FAILURE;
 694
 695         acceptor_flag = kctx->kc_initiate ? 0 : FLAG_SENDER_IS_ACCEPTOR;
 696
 697         /* fill krb5 header */
 698         LASSERT(token->len >= sizeof(*khdr));
 699         khdr = (struct krb5_header *) token->data;
 700
 701         khdr->kh_tok_id = cpu_to_be16(KG_TOK_MIC_MSG);
 702         khdr->kh_flags = acceptor_flag;
 703         khdr->kh_filler = 0xff;
 704         khdr->kh_ec = cpu_to_be16(0xffff);
 705         khdr->kh_rrc = cpu_to_be16(0xffff);
 706         spin_lock(&krb5_seq_lock);
 707         khdr->kh_seq = cpu_to_be64(kctx->kc_seq_send++);
 708         spin_unlock(&krb5_seq_lock);
 709
 710         /* checksum */
 711         if (krb5_make_checksum(kctx->kc_enctype, &kctx->kc_keyc,
 712                                khdr, msgcnt, msgs, &cksum))
 713                 goto out_err;
 714
 715         LASSERT(cksum.len >= ke->ke_hash_size);
 716         LASSERT(token->len >= sizeof(*khdr) + ke->ke_hash_size);
 717         memcpy(khdr + 1, cksum.data + cksum.len - ke->ke_hash_size,
 718                ke->ke_hash_size);
 719
 720         token->len = sizeof(*khdr) + ke->ke_hash_size;
 721         rc = GSS_S_COMPLETE;
 722 out_err:
 723         rawobj_free(&cksum);
 724         return rc;
 725 }
 726
 727 static
 728 __u32 gss_verify_mic_kerberos(struct gss_ctx *gctx,
 729                               int msgcnt,
 730                               rawobj_t *msgs,
 731                               rawobj_t *token)
 732 {
 733         struct krb5_ctx     *kctx = gctx->internal_ctx_id;
 734         struct krb5_enctype *ke = &enctypes[kctx->kc_enctype];
 735         struct krb5_header  *khdr;
 736         unsigned char        acceptor_flag;
 737         rawobj_t             cksum = RAWOBJ_EMPTY;
 738         __u32                rc = GSS_S_FAILURE;
 739
 740         acceptor_flag = kctx->kc_initiate ? FLAG_SENDER_IS_ACCEPTOR : 0;
 741
 742         if (token->len < sizeof(*khdr)) {
 743                 CERROR("short signature: %u\n", token->len);
 744                 return GSS_S_DEFECTIVE_TOKEN;
 745         }
 746
 747         khdr = (struct krb5_header *) token->data;
 748
 749         /* sanity checks */
 750         if (be16_to_cpu(khdr->kh_tok_id) != KG_TOK_MIC_MSG) {
 751                 CERROR("bad token id\n");
 752                 return GSS_S_DEFECTIVE_TOKEN;
 753         }
 754         if ((khdr->kh_flags & FLAG_SENDER_IS_ACCEPTOR) != acceptor_flag) {
 755                 CERROR("bad direction flag\n");
 756                 return GSS_S_BAD_SIG;
 757         }
 758         if (khdr->kh_filler != 0xff) {
 759                 CERROR("bad filler\n");
 760                 return GSS_S_DEFECTIVE_TOKEN;
 761         }
 762         if (be16_to_cpu(khdr->kh_ec) != 0xffff ||
 763             be16_to_cpu(khdr->kh_rrc) != 0xffff) {
 764                 CERROR("bad EC or RRC\n");
 765                 return GSS_S_DEFECTIVE_TOKEN;
 766         }
 767
 768         if (token->len < sizeof(*khdr) + ke->ke_hash_size) {
 769                 CERROR("short signature: %u, require %d\n",
 770                        token->len, (int) sizeof(*khdr) + ke->ke_hash_size);
 771                 goto out;
 772         }
 773
 774         if (krb5_make_checksum(kctx->kc_enctype, &kctx->kc_keyc,
 775                                khdr, msgcnt, msgs, &cksum))
 776                 return GSS_S_FAILURE;
 777
 778         LASSERT(cksum.len >= ke->ke_hash_size);
 779         if (memcmp(khdr + 1, cksum.data + cksum.len - ke->ke_hash_size,
 780                    ke->ke_hash_size)) {
 781                 CERROR("checksum mismatch\n");
 782                 rc = GSS_S_BAD_SIG;
 783                 goto out;
 784         }
 785
 786         rc = GSS_S_COMPLETE;
 787 out:
 788         rawobj_free(&cksum);
 789         return rc;
 790 }
 791
 792 static
 793 int add_padding(rawobj_t *msg, int msg_buflen, int blocksize)
 794 {
 795         int padding;
 796
 797         padding = (blocksize - (msg->len & (blocksize - 1))) &
 798                   (blocksize - 1);
 799         if (!padding)
 800                 return 0;
 801
 802         if (msg->len + padding > msg_buflen) {
 803                 CERROR("bufsize %u too small: datalen %u, padding %u\n",
 804                         msg_buflen, msg->len, padding);
 805                 return -EINVAL;
 806         }
 807
 808         memset(msg->data + msg->len, padding, padding);
 809         msg->len += padding;
 810         return 0;
 811 }
 812
 813 static
 814 int krb5_encrypt_rawobjs(struct crypto_tfm *tfm,
 815                          int mode_ecb,
 816                          int inobj_cnt,
 817                          rawobj_t *inobjs,
 818                          rawobj_t *outobj,
 819                          int enc)
 820 {
 821         struct scatterlist src, dst;
 822         __u8               local_iv[16] = {0}, *buf;
 823         __u32              datalen = 0;
 824         int                i, rc;
 825         ENTRY;
 826
 827         buf = outobj->data;
 828
 829         for (i = 0; i < inobj_cnt; i++) {
 830                 LASSERT(buf + inobjs[i].len <= outobj->data + outobj->len);
 831
 832                 buf_to_sg(&src, inobjs[i].data, inobjs[i].len);
 833                 buf_to_sg(&dst, buf, outobj->len - datalen);
 834
 835                 if (mode_ecb) {
 836                         if (enc)
 837                                 rc = crypto_cipher_encrypt(
 838                                         tfm, &dst, &src, src.length);
 839                         else
 840                                 rc = crypto_cipher_decrypt(
 841                                         tfm, &dst, &src, src.length);
 842                 } else {
 843                         if (enc)
 844                                 rc = crypto_cipher_encrypt_iv(
 845                                         tfm, &dst, &src, src.length, local_iv);
 846                         else
 847                                 rc = crypto_cipher_decrypt_iv(
 848                                         tfm, &dst, &src, src.length, local_iv);
 849                 }
 850
 851                 if (rc) {
 852                         CERROR("encrypt error %d\n", rc);
 853                         RETURN(rc);
 854                 }
 855
 856                 datalen += inobjs[i].len;
 857                 buf += inobjs[i].len;
 858         }
 859
 860         outobj->len = datalen;
 861         RETURN(0);
 862 }
 863
 864 static
 865 __u32 gss_wrap_kerberos(struct gss_ctx *gctx,
 866                         rawobj_t *msg,
 867                         int msg_buflen,
 868                         rawobj_t *token)
 869 {
 870         struct krb5_ctx     *kctx = gctx->internal_ctx_id;
 871         struct krb5_enctype *ke = &enctypes[kctx->kc_enctype];
 872         struct krb5_header  *khdr;
 873         unsigned char        acceptor_flag;
 874         int                  blocksize;
 875         rawobj_t             cksum = RAWOBJ_EMPTY;
 876         rawobj_t             data_desc[3], cipher;
 877         __u8                 conf[GSS_MAX_CIPHER_BLOCK];
 878         int                  enc_rc = 0;
 879
 880         LASSERT(ke);
 881         LASSERT(ke->ke_conf_size <= GSS_MAX_CIPHER_BLOCK);
 882         LASSERT(kctx->kc_keye.kb_tfm == NULL ||
 883                 ke->ke_conf_size >=
 884                 crypto_tfm_alg_blocksize(kctx->kc_keye.kb_tfm));
 885
 886         acceptor_flag = kctx->kc_initiate ? 0 : FLAG_SENDER_IS_ACCEPTOR;
 887
 888         /* fill krb5 header */
 889         LASSERT(token->len >= sizeof(*khdr));
 890         khdr = (struct krb5_header *) token->data;
 891
 892         khdr->kh_tok_id = cpu_to_be16(KG_TOK_WRAP_MSG);
 893         khdr->kh_flags = acceptor_flag | FLAG_WRAP_CONFIDENTIAL;
 894         khdr->kh_filler = 0xff;
 895         khdr->kh_ec = cpu_to_be16(0);
 896         khdr->kh_rrc = cpu_to_be16(0);
 897         spin_lock(&krb5_seq_lock);
 898         khdr->kh_seq = cpu_to_be64(kctx->kc_seq_send++);
 899         spin_unlock(&krb5_seq_lock);
 900
 901         /* generate confounder */
 902         get_random_bytes(conf, ke->ke_conf_size);
 903
 904         /* get encryption blocksize. note kc_keye might not associated with
 905          * a tfm, currently only for arcfour-hmac */
 906         if (kctx->kc_enctype == ENCTYPE_ARCFOUR_HMAC) {
 907                 LASSERT(kctx->kc_keye.kb_tfm == NULL);
 908                 blocksize = 1;
 909         } else {
 910                 LASSERT(kctx->kc_keye.kb_tfm);
 911                 blocksize = crypto_tfm_alg_blocksize(kctx->kc_keye.kb_tfm);
 912         }
 913         LASSERT(blocksize <= ke->ke_conf_size);
 914
 915         /* padding the message */
 916         if (add_padding(msg, msg_buflen, blocksize))
 917                 return GSS_S_FAILURE;
 918
 919         /*
 920          * clear text layout, same for both checksum & encryption:
 921          * -----------------------------------------
 922          * | confounder | clear msgs | krb5 header |
 923          * -----------------------------------------
 924          */
 925         data_desc[0].data = conf;
 926         data_desc[0].len = ke->ke_conf_size;
 927         data_desc[1].data = msg->data;
 928         data_desc[1].len = msg->len;
 929         data_desc[2].data = (__u8 *) khdr;
 930         data_desc[2].len = sizeof(*khdr);
 931
 932         /* compute checksum */
 933         if (krb5_make_checksum(kctx->kc_enctype, &kctx->kc_keyi,
 934                                khdr, 3, data_desc, &cksum))
 935                 return GSS_S_FAILURE;
 936         LASSERT(cksum.len >= ke->ke_hash_size);
 937
 938         /* encrypting, cipher text will be directly inplace */
 939         cipher.data = (__u8 *) (khdr + 1);
 940         cipher.len = token->len - sizeof(*khdr);
 941         LASSERT(cipher.len >= ke->ke_conf_size + msg->len + sizeof(*khdr));
 942
 943         if (kctx->kc_enctype == ENCTYPE_ARCFOUR_HMAC) {
 944                 rawobj_t                arc4_keye;
 945                 struct crypto_tfm      *arc4_tfm;
 946
 947                 if (krb5_make_checksum(ENCTYPE_ARCFOUR_HMAC, &kctx->kc_keyi,
 948                                        NULL, 1, &cksum, &arc4_keye)) {
 949                         CERROR("failed to obtain arc4 enc key\n");
 950                         GOTO(arc4_out, enc_rc = -EACCES);
 951                 }
 952
 953                 arc4_tfm = crypto_alloc_tfm("arc4", CRYPTO_TFM_MODE_ECB);
 954                 if (arc4_tfm == NULL) {
 955                         CERROR("failed to alloc tfm arc4 in ECB mode\n");
 956                         GOTO(arc4_out_key, enc_rc = -EACCES);
 957                 }
 958
 959                 if (crypto_cipher_setkey(arc4_tfm,
 960                                          arc4_keye.data, arc4_keye.len)) {
 961                         CERROR("failed to set arc4 key, len %d\n",
 962                                arc4_keye.len);
 963                         GOTO(arc4_out_tfm, enc_rc = -EACCES);
 964                 }
 965
 966                 enc_rc = krb5_encrypt_rawobjs(arc4_tfm, 1,
 967                                               3, data_desc, &cipher, 1);
 968 arc4_out_tfm:
 969                 crypto_free_tfm(arc4_tfm);
 970 arc4_out_key:
 971                 rawobj_free(&arc4_keye);
 972 arc4_out:
 973                 do {} while(0); /* just to avoid compile warning */
 974         } else {
 975                 enc_rc = krb5_encrypt_rawobjs(kctx->kc_keye.kb_tfm, 0,
 976                                               3, data_desc, &cipher, 1);
 977         }
 978
 979         if (enc_rc != 0) {
 980                 rawobj_free(&cksum);
 981                 return GSS_S_FAILURE;
 982         }
 983
 984         /* fill in checksum */
 985         LASSERT(token->len >= sizeof(*khdr) + cipher.len + ke->ke_hash_size);
 986         memcpy((char *)(khdr + 1) + cipher.len,
 987                cksum.data + cksum.len - ke->ke_hash_size,
 988                ke->ke_hash_size);
 989         rawobj_free(&cksum);
 990
 991         /* final token length */
 992         token->len = sizeof(*khdr) + cipher.len + ke->ke_hash_size;
 993         return GSS_S_COMPLETE;
 994 }
 995
 996 static
 997 __u32 gss_unwrap_kerberos(struct gss_ctx  *gctx,
 998                           rawobj_t        *token,
 999                           rawobj_t        *msg)
1000 {
1001         struct krb5_ctx     *kctx = gctx->internal_ctx_id;
1002         struct krb5_enctype *ke = &enctypes[kctx->kc_enctype];
1003         struct krb5_header  *khdr;
1004         unsigned char        acceptor_flag;
1005         unsigned char       *tmpbuf;
1006         int                  blocksize, bodysize;
1007         rawobj_t             cksum = RAWOBJ_EMPTY;
1008         rawobj_t             cipher_in, plain_out;
1009         __u32                rc = GSS_S_FAILURE, enc_rc = 0;
1010
1011         LASSERT(ke);
1012
1013         acceptor_flag = kctx->kc_initiate ? FLAG_SENDER_IS_ACCEPTOR : 0;
1014
1015         if (token->len < sizeof(*khdr)) {
1016                 CERROR("short signature: %u\n", token->len);
1017                 return GSS_S_DEFECTIVE_TOKEN;
1018         }
1019
1020         khdr = (struct krb5_header *) token->data;
1021
1022         /* sanity check header */
1023         if (be16_to_cpu(khdr->kh_tok_id) != KG_TOK_WRAP_MSG) {
1024                 CERROR("bad token id\n");
1025                 return GSS_S_DEFECTIVE_TOKEN;
1026         }
1027         if ((khdr->kh_flags & FLAG_SENDER_IS_ACCEPTOR) != acceptor_flag) {
1028                 CERROR("bad direction flag\n");
1029                 return GSS_S_BAD_SIG;
1030         }
1031         if ((khdr->kh_flags & FLAG_WRAP_CONFIDENTIAL) == 0) {
1032                 CERROR("missing confidential flag\n");
1033                 return GSS_S_BAD_SIG;
1034         }
1035         if (khdr->kh_filler != 0xff) {
1036                 CERROR("bad filler\n");
1037                 return GSS_S_DEFECTIVE_TOKEN;
1038         }
1039         if (be16_to_cpu(khdr->kh_ec) != 0x0 ||
1040             be16_to_cpu(khdr->kh_rrc) != 0x0) {
1041                 CERROR("bad EC or RRC\n");
1042                 return GSS_S_DEFECTIVE_TOKEN;
1043         }
1044
1045         /* block size */
1046         if (kctx->kc_enctype == ENCTYPE_ARCFOUR_HMAC) {
1047                 LASSERT(kctx->kc_keye.kb_tfm == NULL);
1048                 blocksize = 1;
1049         } else {
1050                 LASSERT(kctx->kc_keye.kb_tfm);
1051                 blocksize = crypto_tfm_alg_blocksize(kctx->kc_keye.kb_tfm);
1052         }
1053
1054         /* expected token layout:
1055          * ----------------------------------------
1056          * | krb5 header | cipher text | checksum |
1057          * ----------------------------------------
1058          */
1059         bodysize = token->len - sizeof(*khdr) - ke->ke_hash_size;
1060
1061         if (bodysize % blocksize) {
1062                 CERROR("odd bodysize %d\n", bodysize);
1063                 return GSS_S_DEFECTIVE_TOKEN;
1064         }
1065
1066         if (bodysize <= ke->ke_conf_size + sizeof(*khdr)) {
1067                 CERROR("incomplete token: bodysize %d\n", bodysize);
1068                 return GSS_S_DEFECTIVE_TOKEN;
1069         }
1070
1071         if (msg->len < bodysize - ke->ke_conf_size - sizeof(*khdr)) {
1072                 CERROR("buffer too small: %u, require %d\n",
1073                        msg->len, bodysize - ke->ke_conf_size);
1074                 return GSS_S_FAILURE;
1075         }
1076
1077         /* decrypting */
1078         OBD_ALLOC(tmpbuf, bodysize);
1079         if (!tmpbuf)
1080                 return GSS_S_FAILURE;
1081
1082         cipher_in.data = (__u8 *) (khdr + 1);
1083         cipher_in.len = bodysize;
1084         plain_out.data = tmpbuf;
1085         plain_out.len = bodysize;
1086
1087         if (kctx->kc_enctype == ENCTYPE_ARCFOUR_HMAC) {
1088                 rawobj_t                arc4_keye;
1089                 struct crypto_tfm      *arc4_tfm;
1090
1091                 cksum.data = token->data + token->len - ke->ke_hash_size;
1092                 cksum.len = ke->ke_hash_size;
1093
1094                 if (krb5_make_checksum(ENCTYPE_ARCFOUR_HMAC, &kctx->kc_keyi,
1095                                        NULL, 1, &cksum, &arc4_keye)) {
1096                         CERROR("failed to obtain arc4 enc key\n");
1097                         GOTO(arc4_out, enc_rc = -EACCES);
1098                 }
1099
1100                 arc4_tfm = crypto_alloc_tfm("arc4", CRYPTO_TFM_MODE_ECB);
1101                 if (arc4_tfm == NULL) {
1102                         CERROR("failed to alloc tfm arc4 in ECB mode\n");
1103                         GOTO(arc4_out_key, enc_rc = -EACCES);
1104                 }
1105
1106                 if (crypto_cipher_setkey(arc4_tfm,
1107                                          arc4_keye.data, arc4_keye.len)) {
1108                         CERROR("failed to set arc4 key, len %d\n",
1109                                arc4_keye.len);
1110                         GOTO(arc4_out_tfm, enc_rc = -EACCES);
1111                 }
1112
1113                 enc_rc = krb5_encrypt_rawobjs(arc4_tfm, 1,
1114                                               1, &cipher_in, &plain_out, 0);
1115 arc4_out_tfm:
1116                 crypto_free_tfm(arc4_tfm);
1117 arc4_out_key:
1118                 rawobj_free(&arc4_keye);
1119 arc4_out:
1120                 cksum = RAWOBJ_EMPTY;
1121         } else {
1122                 enc_rc = krb5_encrypt_rawobjs(kctx->kc_keye.kb_tfm, 0,
1123                                               1, &cipher_in, &plain_out, 0);
1124         }
1125
1126         if (enc_rc != 0) {
1127                 CERROR("error decrypt\n");
1128                 goto out_free;
1129         }
1130         LASSERT(plain_out.len == bodysize);
1131
1132         /* expected clear text layout:
1133          * -----------------------------------------
1134          * | confounder | clear msgs | krb5 header |
1135          * -----------------------------------------
1136          */
1137
1138         /* last part must be identical to the krb5 header */
1139         if (memcmp(khdr, plain_out.data + plain_out.len - sizeof(*khdr),
1140                    sizeof(*khdr))) {
1141                 CERROR("decrypted header mismatch\n");
1142                 goto out_free;
1143         }
1144
1145         /* verify checksum */
1146         if (krb5_make_checksum(kctx->kc_enctype, &kctx->kc_keyi,
1147                                khdr, 1, &plain_out, &cksum))
1148                 goto out_free;
1149
1150         LASSERT(cksum.len >= ke->ke_hash_size);
1151         if (memcmp((char *)(khdr + 1) + bodysize,
1152                    cksum.data + cksum.len - ke->ke_hash_size,
1153                    ke->ke_hash_size)) {
1154                 CERROR("cksum mismatch\n");
1155                 goto out_free;
1156         }
1157
1158         msg->len =  bodysize - ke->ke_conf_size - sizeof(*khdr);
1159         memcpy(msg->data, tmpbuf + ke->ke_conf_size, msg->len);
1160
1161         rc = GSS_S_COMPLETE;
1162 out_free:
1163         OBD_FREE(tmpbuf, bodysize);
1164         rawobj_free(&cksum);
1165         return rc;
1166 }
1167
1168 static
1169 __u32 gss_plain_encrypt_kerberos(struct gss_ctx  *ctx,
1170                                  int              length,
1171                                  void            *in_buf,
1172                                  void            *out_buf)
1173 {
1174         struct krb5_ctx        *kctx = ctx->internal_ctx_id;
1175         __u32                   rc;
1176
1177         rc = krb5_encrypt(kctx->kc_keye.kb_tfm, 0,
1178                           NULL, in_buf, out_buf, length);
1179         if (rc)
1180                 CERROR("plain encrypt error: %d\n", rc);
1181
1182         return rc;
1183 }
1184
1185 int gss_display_kerberos(struct gss_ctx        *ctx,
1186                          char                  *buf,
1187                          int                    bufsize)
1188 {
1189         struct krb5_ctx    *kctx = ctx->internal_ctx_id;
1190         int                 written;
1191
1192         written = snprintf(buf, bufsize, "mech: krb5 (%s)\n",
1193                            enctype2str(kctx->kc_enctype));
1194         return written;
1195 }
1196
1197 static struct gss_api_ops gss_kerberos_ops = {
1198         .gss_import_sec_context     = gss_import_sec_context_kerberos,
1199         .gss_copy_reverse_context   = gss_copy_reverse_context_kerberos,
1200         .gss_inquire_context        = gss_inquire_context_kerberos,
1201         .gss_get_mic                = gss_get_mic_kerberos,
1202         .gss_verify_mic             = gss_verify_mic_kerberos,
1203         .gss_wrap                   = gss_wrap_kerberos,
1204         .gss_unwrap                 = gss_unwrap_kerberos,
1205         .gss_plain_encrypt          = gss_plain_encrypt_kerberos,
1206         .gss_delete_sec_context     = gss_delete_sec_context_kerberos,
1207         .gss_display                = gss_display_kerberos,
1208 };
1209
1210 static struct subflavor_desc gss_kerberos_sfs[] = {
1211         {
1212                 .sf_subflavor   = SPTLRPC_SUBFLVR_KRB5N,
1213                 .sf_qop         = 0,
1214                 .sf_service     = SPTLRPC_SVC_NULL,
1215                 .sf_name        = "krb5n"
1216         },
1217         {
1218                 .sf_subflavor   = SPTLRPC_SUBFLVR_KRB5A,
1219                 .sf_qop         = 0,
1220                 .sf_service     = SPTLRPC_SVC_AUTH,
1221                 .sf_name        = "krb5a"
1222         },
1223         {
1224                 .sf_subflavor   = SPTLRPC_SUBFLVR_KRB5I,
1225                 .sf_qop         = 0,
1226                 .sf_service     = SPTLRPC_SVC_INTG,
1227                 .sf_name        = "krb5i"
1228         },
1229         {
1230                 .sf_subflavor   = SPTLRPC_SUBFLVR_KRB5P,
1231                 .sf_qop         = 0,
1232                 .sf_service     = SPTLRPC_SVC_PRIV,
1233                 .sf_name        = "krb5p"
1234         },
1235 };
1236
1237 /*
1238  * currently we leave module owner NULL
1239  */
1240 static struct gss_api_mech gss_kerberos_mech = {
1241         .gm_owner       = NULL, /*THIS_MODULE, */
1242         .gm_name        = "krb5",
1243         .gm_oid         = (rawobj_t)
1244                                 {9, "\052\206\110\206\367\022\001\002\002"},
1245         .gm_ops         = &gss_kerberos_ops,
1246         .gm_sf_num      = 4,
1247         .gm_sfs         = gss_kerberos_sfs,
1248 };
1249
1250 int __init init_kerberos_module(void)
1251 {
1252         int status;
1253
1254         status = lgss_mech_register(&gss_kerberos_mech);
1255         if (status)
1256                 CERROR("Failed to register kerberos gss mechanism!\n");
1257         return status;
1258 }
1259
1260 void __exit cleanup_kerberos_module(void)
1261 {
1262         lgss_mech_unregister(&gss_kerberos_mech);
1263 }