2 * Modifications for Lustre
4 * Copyright (c) 2007, 2010, Oracle and/or its affiliates. All rights reserved.
6 * Copyright (c) 2011, 2015, Intel Corporation.
8 * Author: Eric Mei <ericm@clusterfs.com>
12 * linux/net/sunrpc/gss_krb5_mech.c
13 * linux/net/sunrpc/gss_krb5_crypto.c
14 * linux/net/sunrpc/gss_krb5_seal.c
15 * linux/net/sunrpc/gss_krb5_seqnum.c
16 * linux/net/sunrpc/gss_krb5_unseal.c
18 * Copyright (c) 2001 The Regents of the University of Michigan.
19 * All rights reserved.
21 * Andy Adamson <andros@umich.edu>
22 * J. Bruce Fields <bfields@umich.edu>
24 * Redistribution and use in source and binary forms, with or without
25 * modification, are permitted provided that the following conditions
28 * 1. Redistributions of source code must retain the above copyright
29 * notice, this list of conditions and the following disclaimer.
30 * 2. Redistributions in binary form must reproduce the above copyright
31 * notice, this list of conditions and the following disclaimer in the
32 * documentation and/or other materials provided with the distribution.
33 * 3. Neither the name of the University nor the names of its
34 * contributors may be used to endorse or promote products derived
35 * from this software without specific prior written permission.
37 * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED
38 * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
39 * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
40 * DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
41 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
42 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
43 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
44 * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
45 * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
46 * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
47 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
51 #define DEBUG_SUBSYSTEM S_SEC
52 #include <linux/init.h>
53 #include <linux/module.h>
54 #include <linux/slab.h>
55 #include <linux/crypto.h>
56 #include <linux/mutex.h>
59 #include <obd_class.h>
60 #include <obd_support.h>
61 #include <lustre/lustre_idl.h>
62 #include <lustre_net.h>
63 #include <lustre_import.h>
64 #include <lustre_sec.h>
67 #include "gss_internal.h"
72 static spinlock_t krb5_seq_lock;
76 char *ke_enc_name; /* linux tfm name */
77 char *ke_hash_name; /* linux tfm name */
78 int ke_enc_mode; /* linux tfm mode */
79 int ke_hash_size; /* checksum size */
80 int ke_conf_size; /* confounder size */
81 unsigned int ke_hash_hmac:1; /* is hmac? */
85 * NOTE: for aes128-cts and aes256-cts, MIT implementation use CTS encryption.
86 * but currently we simply CBC with padding, because linux doesn't support CTS
87 * yet. this need to be fixed in the future.
89 static struct krb5_enctype enctypes[] = {
90 [ENCTYPE_DES_CBC_RAW] = { /* des-cbc-md5 */
99 [ENCTYPE_DES3_CBC_RAW] = { /* des3-hmac-sha1 */
108 [ENCTYPE_AES128_CTS_HMAC_SHA1_96] = { /* aes128-cts */
109 "aes128-cts-hmac-sha1-96",
117 [ENCTYPE_AES256_CTS_HMAC_SHA1_96] = { /* aes256-cts */
118 "aes256-cts-hmac-sha1-96",
126 [ENCTYPE_ARCFOUR_HMAC] = { /* arcfour-hmac-md5 */
137 #define MAX_ENCTYPES sizeof(enctypes)/sizeof(struct krb5_enctype)
139 static const char * enctype2str(__u32 enctype)
141 if (enctype < MAX_ENCTYPES && enctypes[enctype].ke_dispname)
142 return enctypes[enctype].ke_dispname;
148 int keyblock_init(struct krb5_keyblock *kb, char *alg_name, int alg_mode)
150 kb->kb_tfm = crypto_alloc_blkcipher(alg_name, alg_mode, 0);
151 if (IS_ERR(kb->kb_tfm)) {
152 CERROR("failed to alloc tfm: %s, mode %d\n",
157 if (crypto_blkcipher_setkey(kb->kb_tfm, kb->kb_key.data, kb->kb_key.len)) {
158 CERROR("failed to set %s key, len %d\n",
159 alg_name, kb->kb_key.len);
167 int krb5_init_keys(struct krb5_ctx *kctx)
169 struct krb5_enctype *ke;
171 if (kctx->kc_enctype >= MAX_ENCTYPES ||
172 enctypes[kctx->kc_enctype].ke_hash_size == 0) {
173 CERROR("unsupported enctype %x\n", kctx->kc_enctype);
177 ke = &enctypes[kctx->kc_enctype];
179 /* tfm arc4 is stateful, user should alloc-use-free by his own */
180 if (kctx->kc_enctype != ENCTYPE_ARCFOUR_HMAC &&
181 keyblock_init(&kctx->kc_keye, ke->ke_enc_name, ke->ke_enc_mode))
184 /* tfm hmac is stateful, user should alloc-use-free by his own */
185 if (ke->ke_hash_hmac == 0 &&
186 keyblock_init(&kctx->kc_keyi, ke->ke_enc_name, ke->ke_enc_mode))
188 if (ke->ke_hash_hmac == 0 &&
189 keyblock_init(&kctx->kc_keyc, ke->ke_enc_name, ke->ke_enc_mode))
196 void keyblock_free(struct krb5_keyblock *kb)
198 rawobj_free(&kb->kb_key);
200 crypto_free_blkcipher(kb->kb_tfm);
204 int keyblock_dup(struct krb5_keyblock *new, struct krb5_keyblock *kb)
206 return rawobj_dup(&new->kb_key, &kb->kb_key);
210 int get_bytes(char **ptr, const char *end, void *res, int len)
215 if (q > end || q < p)
223 int get_rawobj(char **ptr, const char *end, rawobj_t *res)
229 if (get_bytes(&p, end, &len, sizeof(len)))
233 if (q > end || q < p)
236 OBD_ALLOC_LARGE(res->data, len);
241 memcpy(res->data, p, len);
247 int get_keyblock(char **ptr, const char *end,
248 struct krb5_keyblock *kb, __u32 keysize)
252 OBD_ALLOC_LARGE(buf, keysize);
256 if (get_bytes(ptr, end, buf, keysize)) {
257 OBD_FREE_LARGE(buf, keysize);
261 kb->kb_key.len = keysize;
262 kb->kb_key.data = buf;
267 void delete_context_kerberos(struct krb5_ctx *kctx)
269 rawobj_free(&kctx->kc_mech_used);
271 keyblock_free(&kctx->kc_keye);
272 keyblock_free(&kctx->kc_keyi);
273 keyblock_free(&kctx->kc_keyc);
277 __u32 import_context_rfc1964(struct krb5_ctx *kctx, char *p, char *end)
279 unsigned int tmp_uint, keysize;
282 if (get_bytes(&p, end, &tmp_uint, sizeof(tmp_uint)))
284 kctx->kc_seed_init = (tmp_uint != 0);
287 if (get_bytes(&p, end, kctx->kc_seed, sizeof(kctx->kc_seed)))
290 /* sign/seal algorithm, not really used now */
291 if (get_bytes(&p, end, &tmp_uint, sizeof(tmp_uint)) ||
292 get_bytes(&p, end, &tmp_uint, sizeof(tmp_uint)))
296 if (get_bytes(&p, end, &kctx->kc_endtime, sizeof(kctx->kc_endtime)))
300 if (get_bytes(&p, end, &tmp_uint, sizeof(tmp_uint)))
302 kctx->kc_seq_send = tmp_uint;
305 if (get_rawobj(&p, end, &kctx->kc_mech_used))
308 /* old style enc/seq keys in format:
312 * we decompose them to fit into the new context
316 if (get_bytes(&p, end, &kctx->kc_enctype, sizeof(kctx->kc_enctype)))
319 if (get_bytes(&p, end, &keysize, sizeof(keysize)))
322 if (get_keyblock(&p, end, &kctx->kc_keye, keysize))
326 if (get_bytes(&p, end, &tmp_uint, sizeof(tmp_uint)) ||
327 tmp_uint != kctx->kc_enctype)
330 if (get_bytes(&p, end, &tmp_uint, sizeof(tmp_uint)) ||
334 if (get_keyblock(&p, end, &kctx->kc_keyc, keysize))
337 /* old style fallback */
338 if (keyblock_dup(&kctx->kc_keyi, &kctx->kc_keyc))
344 CDEBUG(D_SEC, "successfully imported rfc1964 context\n");
347 return GSS_S_FAILURE;
350 /* Flags for version 2 context flags */
351 #define KRB5_CTX_FLAG_INITIATOR 0x00000001
352 #define KRB5_CTX_FLAG_CFX 0x00000002
353 #define KRB5_CTX_FLAG_ACCEPTOR_SUBKEY 0x00000004
356 __u32 import_context_rfc4121(struct krb5_ctx *kctx, char *p, char *end)
358 unsigned int tmp_uint, keysize;
361 if (get_bytes(&p, end, &kctx->kc_endtime, sizeof(kctx->kc_endtime)))
365 if (get_bytes(&p, end, &tmp_uint, sizeof(tmp_uint)))
368 if (tmp_uint & KRB5_CTX_FLAG_INITIATOR)
369 kctx->kc_initiate = 1;
370 if (tmp_uint & KRB5_CTX_FLAG_CFX)
372 if (tmp_uint & KRB5_CTX_FLAG_ACCEPTOR_SUBKEY)
373 kctx->kc_have_acceptor_subkey = 1;
376 if (get_bytes(&p, end, &kctx->kc_seq_send, sizeof(kctx->kc_seq_send)))
380 if (get_bytes(&p, end, &kctx->kc_enctype, sizeof(kctx->kc_enctype)))
383 /* size of each key */
384 if (get_bytes(&p, end, &keysize, sizeof(keysize)))
387 /* number of keys - should always be 3 */
388 if (get_bytes(&p, end, &tmp_uint, sizeof(tmp_uint)))
392 CERROR("Invalid number of keys: %u\n", tmp_uint);
397 if (get_keyblock(&p, end, &kctx->kc_keye, keysize))
400 if (get_keyblock(&p, end, &kctx->kc_keyi, keysize))
403 if (get_keyblock(&p, end, &kctx->kc_keyc, keysize))
406 CDEBUG(D_SEC, "successfully imported v2 context\n");
409 return GSS_S_FAILURE;
413 * The whole purpose here is trying to keep user level gss context parsing
414 * from nfs-utils unchanged as possible as we can, they are not quite mature
415 * yet, and many stuff still not clear, like heimdal etc.
418 __u32 gss_import_sec_context_kerberos(rawobj_t *inbuf,
419 struct gss_ctx *gctx)
421 struct krb5_ctx *kctx;
422 char *p = (char *) inbuf->data;
423 char *end = (char *) (inbuf->data + inbuf->len);
424 unsigned int tmp_uint, rc;
426 if (get_bytes(&p, end, &tmp_uint, sizeof(tmp_uint))) {
427 CERROR("Fail to read version\n");
428 return GSS_S_FAILURE;
431 /* only support 0, 1 for the moment */
433 CERROR("Invalid version %u\n", tmp_uint);
434 return GSS_S_FAILURE;
439 return GSS_S_FAILURE;
441 if (tmp_uint == 0 || tmp_uint == 1) {
442 kctx->kc_initiate = tmp_uint;
443 rc = import_context_rfc1964(kctx, p, end);
445 rc = import_context_rfc4121(kctx, p, end);
449 rc = krb5_init_keys(kctx);
452 delete_context_kerberos(kctx);
455 return GSS_S_FAILURE;
458 gctx->internal_ctx_id = kctx;
459 return GSS_S_COMPLETE;
463 __u32 gss_copy_reverse_context_kerberos(struct gss_ctx *gctx,
464 struct gss_ctx *gctx_new)
466 struct krb5_ctx *kctx = gctx->internal_ctx_id;
467 struct krb5_ctx *knew;
471 return GSS_S_FAILURE;
473 knew->kc_initiate = kctx->kc_initiate ? 0 : 1;
474 knew->kc_cfx = kctx->kc_cfx;
475 knew->kc_seed_init = kctx->kc_seed_init;
476 knew->kc_have_acceptor_subkey = kctx->kc_have_acceptor_subkey;
477 knew->kc_endtime = kctx->kc_endtime;
479 memcpy(knew->kc_seed, kctx->kc_seed, sizeof(kctx->kc_seed));
480 knew->kc_seq_send = kctx->kc_seq_recv;
481 knew->kc_seq_recv = kctx->kc_seq_send;
482 knew->kc_enctype = kctx->kc_enctype;
484 if (rawobj_dup(&knew->kc_mech_used, &kctx->kc_mech_used))
487 if (keyblock_dup(&knew->kc_keye, &kctx->kc_keye))
489 if (keyblock_dup(&knew->kc_keyi, &kctx->kc_keyi))
491 if (keyblock_dup(&knew->kc_keyc, &kctx->kc_keyc))
493 if (krb5_init_keys(knew))
496 gctx_new->internal_ctx_id = knew;
497 CDEBUG(D_SEC, "successfully copied reverse context\n");
498 return GSS_S_COMPLETE;
501 delete_context_kerberos(knew);
503 return GSS_S_FAILURE;
507 __u32 gss_inquire_context_kerberos(struct gss_ctx *gctx,
508 unsigned long *endtime)
510 struct krb5_ctx *kctx = gctx->internal_ctx_id;
512 *endtime = (unsigned long) ((__u32) kctx->kc_endtime);
513 return GSS_S_COMPLETE;
517 void gss_delete_sec_context_kerberos(void *internal_ctx)
519 struct krb5_ctx *kctx = internal_ctx;
521 delete_context_kerberos(kctx);
526 * Should be used for buffers allocated with k/vmalloc().
528 * Dispose of @sgt with teardown_sgtable().
530 * @prealloc_sg is to avoid memory allocation inside sg_alloc_table()
531 * in cases where a single sg is sufficient. No attempt to reduce the
532 * number of sgs by squeezing physically contiguous pages together is
533 * made though, for simplicity.
535 * This function is copied from the ceph filesystem code.
537 static int setup_sgtable(struct sg_table *sgt, struct scatterlist *prealloc_sg,
538 const void *buf, unsigned int buf_len)
540 struct scatterlist *sg;
541 const bool is_vmalloc = is_vmalloc_addr(buf);
542 unsigned int off = offset_in_page(buf);
543 unsigned int chunk_cnt = 1;
544 unsigned int chunk_len = PAGE_ALIGN(off + buf_len);
549 memset(sgt, 0, sizeof(*sgt));
554 chunk_cnt = chunk_len >> PAGE_SHIFT;
555 chunk_len = PAGE_SIZE;
559 ret = sg_alloc_table(sgt, chunk_cnt, GFP_NOFS);
563 WARN_ON(chunk_cnt != 1);
564 sg_init_table(prealloc_sg, 1);
565 sgt->sgl = prealloc_sg;
566 sgt->nents = sgt->orig_nents = 1;
569 for_each_sg(sgt->sgl, sg, sgt->orig_nents, i) {
571 unsigned int len = min(chunk_len - off, buf_len);
574 page = vmalloc_to_page(buf);
576 page = virt_to_page(buf);
578 sg_set_page(sg, page, len, off);
585 WARN_ON(buf_len != 0);
590 static void teardown_sgtable(struct sg_table *sgt)
592 if (sgt->orig_nents > 1)
597 __u32 krb5_encrypt(struct crypto_blkcipher *tfm,
604 struct sg_table sg_out;
605 struct blkcipher_desc desc;
606 struct scatterlist sg;
607 __u8 local_iv[16] = {0};
612 desc.info = local_iv;
615 if (length % crypto_blkcipher_blocksize(tfm) != 0) {
616 CERROR("output length %d mismatch blocksize %d\n",
617 length, crypto_blkcipher_blocksize(tfm));
621 if (crypto_blkcipher_ivsize(tfm) > 16) {
622 CERROR("iv size too large %d\n", crypto_blkcipher_ivsize(tfm));
627 memcpy(local_iv, iv, crypto_blkcipher_ivsize(tfm));
629 memcpy(out, in, length);
631 ret = setup_sgtable(&sg_out, &sg, out, length);
636 ret = crypto_blkcipher_decrypt_iv(&desc, sg_out.sgl,
639 ret = crypto_blkcipher_encrypt_iv(&desc, sg_out.sgl,
642 teardown_sgtable(&sg_out);
648 int krb5_digest_hmac(struct crypto_hash *tfm,
650 struct krb5_header *khdr,
651 int msgcnt, rawobj_t *msgs,
652 int iovcnt, lnet_kiov_t *iovs,
655 struct hash_desc desc;
657 struct scatterlist sg[1];
660 crypto_hash_setkey(tfm, key->data, key->len);
664 crypto_hash_init(&desc);
666 for (i = 0; i < msgcnt; i++) {
667 if (msgs[i].len == 0)
670 rc = setup_sgtable(&sgt, sg, msgs[i].data, msgs[i].len);
674 crypto_hash_update(&desc, sgt.sgl, msgs[i].len);
676 teardown_sgtable(&sgt);
679 for (i = 0; i < iovcnt; i++) {
680 if (iovs[i].kiov_len == 0)
683 sg_init_table(sg, 1);
684 sg_set_page(&sg[0], iovs[i].kiov_page, iovs[i].kiov_len,
685 iovs[i].kiov_offset);
686 crypto_hash_update(&desc, sg, iovs[i].kiov_len);
690 rc = setup_sgtable(&sgt, sg, (char *) khdr, sizeof(*khdr));
694 crypto_hash_update(&desc, sgt.sgl, sizeof(*khdr));
696 teardown_sgtable(&sgt);
699 return crypto_hash_final(&desc, cksum->data);
703 int krb5_digest_norm(struct crypto_hash *tfm,
704 struct krb5_keyblock *kb,
705 struct krb5_header *khdr,
706 int msgcnt, rawobj_t *msgs,
707 int iovcnt, lnet_kiov_t *iovs,
710 struct hash_desc desc;
711 struct scatterlist sg[1];
719 crypto_hash_init(&desc);
721 for (i = 0; i < msgcnt; i++) {
722 if (msgs[i].len == 0)
725 rc = setup_sgtable(&sgt, sg, msgs[i].data, msgs[i].len);
729 crypto_hash_update(&desc, sgt.sgl, msgs[i].len);
731 teardown_sgtable(&sgt);
734 for (i = 0; i < iovcnt; i++) {
735 if (iovs[i].kiov_len == 0)
738 sg_init_table(sg, 1);
739 sg_set_page(&sg[0], iovs[i].kiov_page, iovs[i].kiov_len,
740 iovs[i].kiov_offset);
741 crypto_hash_update(&desc, sg, iovs[i].kiov_len);
745 rc = setup_sgtable(&sgt, sg, (char *) khdr, sizeof(*khdr));
749 crypto_hash_update(&desc, sgt.sgl, sizeof(*khdr));
751 teardown_sgtable(&sgt);
754 crypto_hash_final(&desc, cksum->data);
756 return krb5_encrypt(kb->kb_tfm, 0, NULL, cksum->data,
757 cksum->data, cksum->len);
761 * compute (keyed/keyless) checksum against the plain text which appended
762 * with krb5 wire token header.
765 __s32 krb5_make_checksum(__u32 enctype,
766 struct krb5_keyblock *kb,
767 struct krb5_header *khdr,
768 int msgcnt, rawobj_t *msgs,
769 int iovcnt, lnet_kiov_t *iovs,
772 struct krb5_enctype *ke = &enctypes[enctype];
773 struct crypto_hash *tfm;
774 __u32 code = GSS_S_FAILURE;
777 if (!(tfm = crypto_alloc_hash(ke->ke_hash_name, 0, 0))) {
778 CERROR("failed to alloc TFM: %s\n", ke->ke_hash_name);
779 return GSS_S_FAILURE;
782 cksum->len = crypto_hash_digestsize(tfm);
783 OBD_ALLOC_LARGE(cksum->data, cksum->len);
789 if (ke->ke_hash_hmac)
790 rc = krb5_digest_hmac(tfm, &kb->kb_key,
791 khdr, msgcnt, msgs, iovcnt, iovs, cksum);
793 rc = krb5_digest_norm(tfm, kb,
794 khdr, msgcnt, msgs, iovcnt, iovs, cksum);
797 code = GSS_S_COMPLETE;
799 crypto_free_hash(tfm);
803 static void fill_krb5_header(struct krb5_ctx *kctx,
804 struct krb5_header *khdr,
807 unsigned char acceptor_flag;
809 acceptor_flag = kctx->kc_initiate ? 0 : FLAG_SENDER_IS_ACCEPTOR;
812 khdr->kh_tok_id = cpu_to_be16(KG_TOK_WRAP_MSG);
813 khdr->kh_flags = acceptor_flag | FLAG_WRAP_CONFIDENTIAL;
814 khdr->kh_ec = cpu_to_be16(0);
815 khdr->kh_rrc = cpu_to_be16(0);
817 khdr->kh_tok_id = cpu_to_be16(KG_TOK_MIC_MSG);
818 khdr->kh_flags = acceptor_flag;
819 khdr->kh_ec = cpu_to_be16(0xffff);
820 khdr->kh_rrc = cpu_to_be16(0xffff);
823 khdr->kh_filler = 0xff;
824 spin_lock(&krb5_seq_lock);
825 khdr->kh_seq = cpu_to_be64(kctx->kc_seq_send++);
826 spin_unlock(&krb5_seq_lock);
829 static __u32 verify_krb5_header(struct krb5_ctx *kctx,
830 struct krb5_header *khdr,
833 unsigned char acceptor_flag;
834 __u16 tok_id, ec_rrc;
836 acceptor_flag = kctx->kc_initiate ? FLAG_SENDER_IS_ACCEPTOR : 0;
839 tok_id = KG_TOK_WRAP_MSG;
842 tok_id = KG_TOK_MIC_MSG;
847 if (be16_to_cpu(khdr->kh_tok_id) != tok_id) {
848 CERROR("bad token id\n");
849 return GSS_S_DEFECTIVE_TOKEN;
851 if ((khdr->kh_flags & FLAG_SENDER_IS_ACCEPTOR) != acceptor_flag) {
852 CERROR("bad direction flag\n");
853 return GSS_S_BAD_SIG;
855 if (privacy && (khdr->kh_flags & FLAG_WRAP_CONFIDENTIAL) == 0) {
856 CERROR("missing confidential flag\n");
857 return GSS_S_BAD_SIG;
859 if (khdr->kh_filler != 0xff) {
860 CERROR("bad filler\n");
861 return GSS_S_DEFECTIVE_TOKEN;
863 if (be16_to_cpu(khdr->kh_ec) != ec_rrc ||
864 be16_to_cpu(khdr->kh_rrc) != ec_rrc) {
865 CERROR("bad EC or RRC\n");
866 return GSS_S_DEFECTIVE_TOKEN;
868 return GSS_S_COMPLETE;
872 __u32 gss_get_mic_kerberos(struct gss_ctx *gctx,
879 struct krb5_ctx *kctx = gctx->internal_ctx_id;
880 struct krb5_enctype *ke = &enctypes[kctx->kc_enctype];
881 struct krb5_header *khdr;
882 rawobj_t cksum = RAWOBJ_EMPTY;
884 /* fill krb5 header */
885 LASSERT(token->len >= sizeof(*khdr));
886 khdr = (struct krb5_header *) token->data;
887 fill_krb5_header(kctx, khdr, 0);
890 if (krb5_make_checksum(kctx->kc_enctype, &kctx->kc_keyc,
891 khdr, msgcnt, msgs, iovcnt, iovs, &cksum))
892 return GSS_S_FAILURE;
894 LASSERT(cksum.len >= ke->ke_hash_size);
895 LASSERT(token->len >= sizeof(*khdr) + ke->ke_hash_size);
896 memcpy(khdr + 1, cksum.data + cksum.len - ke->ke_hash_size,
899 token->len = sizeof(*khdr) + ke->ke_hash_size;
901 return GSS_S_COMPLETE;
905 __u32 gss_verify_mic_kerberos(struct gss_ctx *gctx,
912 struct krb5_ctx *kctx = gctx->internal_ctx_id;
913 struct krb5_enctype *ke = &enctypes[kctx->kc_enctype];
914 struct krb5_header *khdr;
915 rawobj_t cksum = RAWOBJ_EMPTY;
918 if (token->len < sizeof(*khdr)) {
919 CERROR("short signature: %u\n", token->len);
920 return GSS_S_DEFECTIVE_TOKEN;
923 khdr = (struct krb5_header *) token->data;
925 major = verify_krb5_header(kctx, khdr, 0);
926 if (major != GSS_S_COMPLETE) {
927 CERROR("bad krb5 header\n");
931 if (token->len < sizeof(*khdr) + ke->ke_hash_size) {
932 CERROR("short signature: %u, require %d\n",
933 token->len, (int) sizeof(*khdr) + ke->ke_hash_size);
934 return GSS_S_FAILURE;
937 if (krb5_make_checksum(kctx->kc_enctype, &kctx->kc_keyc,
938 khdr, msgcnt, msgs, iovcnt, iovs, &cksum)) {
939 CERROR("failed to make checksum\n");
940 return GSS_S_FAILURE;
943 LASSERT(cksum.len >= ke->ke_hash_size);
944 if (memcmp(khdr + 1, cksum.data + cksum.len - ke->ke_hash_size,
946 CERROR("checksum mismatch\n");
948 return GSS_S_BAD_SIG;
952 return GSS_S_COMPLETE;
956 int add_padding(rawobj_t *msg, int msg_buflen, int blocksize)
960 padding = (blocksize - (msg->len & (blocksize - 1))) &
965 if (msg->len + padding > msg_buflen) {
966 CERROR("bufsize %u too small: datalen %u, padding %u\n",
967 msg_buflen, msg->len, padding);
971 memset(msg->data + msg->len, padding, padding);
977 int krb5_encrypt_rawobjs(struct crypto_blkcipher *tfm,
984 struct blkcipher_desc desc;
985 struct scatterlist src, dst;
986 struct sg_table sg_src, sg_dst;
987 __u8 local_iv[16] = {0}, *buf;
994 desc.info = local_iv;
997 for (i = 0; i < inobj_cnt; i++) {
998 LASSERT(buf + inobjs[i].len <= outobj->data + outobj->len);
1000 rc = setup_sgtable(&sg_src, &src, inobjs[i].data,
1005 rc = setup_sgtable(&sg_dst, &dst, buf,
1006 outobj->len - datalen);
1008 teardown_sgtable(&sg_src);
1014 rc = crypto_blkcipher_encrypt(&desc, sg_dst.sgl,
1018 rc = crypto_blkcipher_decrypt(&desc, sg_dst.sgl,
1023 rc = crypto_blkcipher_encrypt_iv(&desc,
1028 rc = crypto_blkcipher_decrypt_iv(&desc,
1034 teardown_sgtable(&sg_src);
1035 teardown_sgtable(&sg_dst);
1038 CERROR("encrypt error %d\n", rc);
1042 datalen += inobjs[i].len;
1043 buf += inobjs[i].len;
1046 outobj->len = datalen;
1051 * if adj_nob != 0, we adjust desc->bd_nob to the actual cipher text size.
1054 int krb5_encrypt_bulk(struct crypto_blkcipher *tfm,
1055 struct krb5_header *khdr,
1057 struct ptlrpc_bulk_desc *desc,
1061 struct blkcipher_desc ciph_desc;
1062 __u8 local_iv[16] = {0};
1063 struct scatterlist src, dst;
1064 struct sg_table sg_src, sg_dst;
1065 int blocksize, i, rc, nob = 0;
1067 LASSERT(ptlrpc_is_bulk_desc_kiov(desc->bd_type));
1068 LASSERT(desc->bd_iov_count);
1069 LASSERT(GET_ENC_KIOV(desc));
1071 blocksize = crypto_blkcipher_blocksize(tfm);
1072 LASSERT(blocksize > 1);
1073 LASSERT(cipher->len == blocksize + sizeof(*khdr));
1075 ciph_desc.tfm = tfm;
1076 ciph_desc.info = local_iv;
1077 ciph_desc.flags = 0;
1079 /* encrypt confounder */
1080 rc = setup_sgtable(&sg_src, &src, confounder, blocksize);
1084 rc = setup_sgtable(&sg_dst, &dst, cipher->data, blocksize);
1086 teardown_sgtable(&sg_src);
1090 rc = crypto_blkcipher_encrypt_iv(&ciph_desc, sg_dst.sgl,
1091 sg_src.sgl, blocksize);
1093 teardown_sgtable(&sg_dst);
1094 teardown_sgtable(&sg_src);
1097 CERROR("error to encrypt confounder: %d\n", rc);
1101 /* encrypt clear pages */
1102 for (i = 0; i < desc->bd_iov_count; i++) {
1103 sg_init_table(&src, 1);
1104 sg_set_page(&src, BD_GET_KIOV(desc, i).kiov_page,
1105 (BD_GET_KIOV(desc, i).kiov_len +
1108 BD_GET_KIOV(desc, i).kiov_offset);
1111 sg_init_table(&dst, 1);
1112 sg_set_page(&dst, BD_GET_ENC_KIOV(desc, i).kiov_page,
1113 src.length, src.offset);
1115 BD_GET_ENC_KIOV(desc, i).kiov_offset = dst.offset;
1116 BD_GET_ENC_KIOV(desc, i).kiov_len = dst.length;
1118 rc = crypto_blkcipher_encrypt_iv(&ciph_desc, &dst, &src,
1121 CERROR("error to encrypt page: %d\n", rc);
1126 /* encrypt krb5 header */
1127 rc = setup_sgtable(&sg_src, &src, khdr, sizeof(*khdr));
1131 rc = setup_sgtable(&sg_dst, &dst, cipher->data + blocksize,
1134 teardown_sgtable(&sg_src);
1138 rc = crypto_blkcipher_encrypt_iv(&ciph_desc, sg_dst.sgl, sg_src.sgl,
1141 teardown_sgtable(&sg_dst);
1142 teardown_sgtable(&sg_src);
1145 CERROR("error to encrypt krb5 header: %d\n", rc);
1156 * desc->bd_nob_transferred is the size of cipher text received.
1157 * desc->bd_nob is the target size of plain text supposed to be.
1159 * if adj_nob != 0, we adjust each page's kiov_len to the actual
1161 * - for client read: we don't know data size for each page, so
1162 * bd_iov[]->kiov_len is set to PAGE_SIZE, but actual data received might
1163 * be smaller, so we need to adjust it according to
1164 * bd_u.bd_kiov.bd_enc_vec[]->kiov_len.
1165 * this means we DO NOT support the situation that server send an odd size
1166 * data in a page which is not the last one.
1167 * - for server write: we knows exactly data size for each page being expected,
1168 * thus kiov_len is accurate already, so we should not adjust it at all.
1169 * and bd_u.bd_kiov.bd_enc_vec[]->kiov_len should be
1170 * round_up(bd_iov[]->kiov_len) which
1171 * should have been done by prep_bulk().
1174 int krb5_decrypt_bulk(struct crypto_blkcipher *tfm,
1175 struct krb5_header *khdr,
1176 struct ptlrpc_bulk_desc *desc,
1181 struct blkcipher_desc ciph_desc;
1182 __u8 local_iv[16] = {0};
1183 struct scatterlist src, dst;
1184 struct sg_table sg_src, sg_dst;
1185 int ct_nob = 0, pt_nob = 0;
1186 int blocksize, i, rc;
1188 LASSERT(ptlrpc_is_bulk_desc_kiov(desc->bd_type));
1189 LASSERT(desc->bd_iov_count);
1190 LASSERT(GET_ENC_KIOV(desc));
1191 LASSERT(desc->bd_nob_transferred);
1193 blocksize = crypto_blkcipher_blocksize(tfm);
1194 LASSERT(blocksize > 1);
1195 LASSERT(cipher->len == blocksize + sizeof(*khdr));
1197 ciph_desc.tfm = tfm;
1198 ciph_desc.info = local_iv;
1199 ciph_desc.flags = 0;
1201 if (desc->bd_nob_transferred % blocksize) {
1202 CERROR("odd transferred nob: %d\n", desc->bd_nob_transferred);
1206 /* decrypt head (confounder) */
1207 rc = setup_sgtable(&sg_src, &src, cipher->data, blocksize);
1211 rc = setup_sgtable(&sg_dst, &dst, plain->data, blocksize);
1213 teardown_sgtable(&sg_src);
1217 rc = crypto_blkcipher_decrypt_iv(&ciph_desc, sg_dst.sgl,
1218 sg_src.sgl, blocksize);
1220 teardown_sgtable(&sg_dst);
1221 teardown_sgtable(&sg_src);
1224 CERROR("error to decrypt confounder: %d\n", rc);
1228 for (i = 0; i < desc->bd_iov_count && ct_nob < desc->bd_nob_transferred;
1230 if (BD_GET_ENC_KIOV(desc, i).kiov_offset % blocksize
1232 BD_GET_ENC_KIOV(desc, i).kiov_len % blocksize
1234 CERROR("page %d: odd offset %u len %u, blocksize %d\n",
1235 i, BD_GET_ENC_KIOV(desc, i).kiov_offset,
1236 BD_GET_ENC_KIOV(desc, i).kiov_len,
1242 if (ct_nob + BD_GET_ENC_KIOV(desc, i).kiov_len >
1243 desc->bd_nob_transferred)
1244 BD_GET_ENC_KIOV(desc, i).kiov_len =
1245 desc->bd_nob_transferred - ct_nob;
1247 BD_GET_KIOV(desc, i).kiov_len =
1248 BD_GET_ENC_KIOV(desc, i).kiov_len;
1249 if (pt_nob + BD_GET_ENC_KIOV(desc, i).kiov_len >
1251 BD_GET_KIOV(desc, i).kiov_len =
1252 desc->bd_nob - pt_nob;
1254 /* this should be guaranteed by LNET */
1255 LASSERT(ct_nob + BD_GET_ENC_KIOV(desc, i).
1257 desc->bd_nob_transferred);
1258 LASSERT(BD_GET_KIOV(desc, i).kiov_len <=
1259 BD_GET_ENC_KIOV(desc, i).kiov_len);
1262 if (BD_GET_ENC_KIOV(desc, i).kiov_len == 0)
1265 sg_init_table(&src, 1);
1266 sg_set_page(&src, BD_GET_ENC_KIOV(desc, i).kiov_page,
1267 BD_GET_ENC_KIOV(desc, i).kiov_len,
1268 BD_GET_ENC_KIOV(desc, i).kiov_offset);
1270 if (BD_GET_KIOV(desc, i).kiov_len % blocksize == 0)
1271 sg_assign_page(&dst,
1272 BD_GET_KIOV(desc, i).kiov_page);
1274 rc = crypto_blkcipher_decrypt_iv(&ciph_desc, &dst, &src,
1277 CERROR("error to decrypt page: %d\n", rc);
1281 if (BD_GET_KIOV(desc, i).kiov_len % blocksize != 0) {
1282 memcpy(page_address(BD_GET_KIOV(desc, i).kiov_page) +
1283 BD_GET_KIOV(desc, i).kiov_offset,
1284 page_address(BD_GET_ENC_KIOV(desc, i).
1286 BD_GET_KIOV(desc, i).kiov_offset,
1287 BD_GET_KIOV(desc, i).kiov_len);
1290 ct_nob += BD_GET_ENC_KIOV(desc, i).kiov_len;
1291 pt_nob += BD_GET_KIOV(desc, i).kiov_len;
1294 if (unlikely(ct_nob != desc->bd_nob_transferred)) {
1295 CERROR("%d cipher text transferred but only %d decrypted\n",
1296 desc->bd_nob_transferred, ct_nob);
1300 if (unlikely(!adj_nob && pt_nob != desc->bd_nob)) {
1301 CERROR("%d plain text expected but only %d received\n",
1302 desc->bd_nob, pt_nob);
1306 /* if needed, clear up the rest unused iovs */
1308 while (i < desc->bd_iov_count)
1309 BD_GET_KIOV(desc, i++).kiov_len = 0;
1311 /* decrypt tail (krb5 header) */
1312 rc = setup_sgtable(&sg_src, &src, cipher->data + blocksize,
1317 rc = setup_sgtable(&sg_dst, &dst, cipher->data + blocksize,
1320 teardown_sgtable(&sg_src);
1324 rc = crypto_blkcipher_decrypt_iv(&ciph_desc, sg_dst.sgl, sg_src.sgl,
1327 teardown_sgtable(&sg_src);
1328 teardown_sgtable(&sg_dst);
1331 CERROR("error to decrypt tail: %d\n", rc);
1335 if (memcmp(cipher->data + blocksize, khdr, sizeof(*khdr))) {
1336 CERROR("krb5 header doesn't match\n");
1344 __u32 gss_wrap_kerberos(struct gss_ctx *gctx,
1350 struct krb5_ctx *kctx = gctx->internal_ctx_id;
1351 struct krb5_enctype *ke = &enctypes[kctx->kc_enctype];
1352 struct krb5_header *khdr;
1354 rawobj_t cksum = RAWOBJ_EMPTY;
1355 rawobj_t data_desc[3], cipher;
1356 __u8 conf[GSS_MAX_CIPHER_BLOCK];
1360 LASSERT(ke->ke_conf_size <= GSS_MAX_CIPHER_BLOCK);
1361 LASSERT(kctx->kc_keye.kb_tfm == NULL ||
1363 crypto_blkcipher_blocksize(kctx->kc_keye.kb_tfm));
1366 * final token format:
1367 * ---------------------------------------------------
1368 * | krb5 header | cipher text | checksum (16 bytes) |
1369 * ---------------------------------------------------
1372 /* fill krb5 header */
1373 LASSERT(token->len >= sizeof(*khdr));
1374 khdr = (struct krb5_header *) token->data;
1375 fill_krb5_header(kctx, khdr, 1);
1377 /* generate confounder */
1378 cfs_get_random_bytes(conf, ke->ke_conf_size);
1380 /* get encryption blocksize. note kc_keye might not associated with
1381 * a tfm, currently only for arcfour-hmac */
1382 if (kctx->kc_enctype == ENCTYPE_ARCFOUR_HMAC) {
1383 LASSERT(kctx->kc_keye.kb_tfm == NULL);
1386 LASSERT(kctx->kc_keye.kb_tfm);
1387 blocksize = crypto_blkcipher_blocksize(kctx->kc_keye.kb_tfm);
1389 LASSERT(blocksize <= ke->ke_conf_size);
1391 /* padding the message */
1392 if (add_padding(msg, msg_buflen, blocksize))
1393 return GSS_S_FAILURE;
1396 * clear text layout for checksum:
1397 * ------------------------------------------------------
1398 * | confounder | gss header | clear msgs | krb5 header |
1399 * ------------------------------------------------------
1401 data_desc[0].data = conf;
1402 data_desc[0].len = ke->ke_conf_size;
1403 data_desc[1].data = gsshdr->data;
1404 data_desc[1].len = gsshdr->len;
1405 data_desc[2].data = msg->data;
1406 data_desc[2].len = msg->len;
1408 /* compute checksum */
1409 if (krb5_make_checksum(kctx->kc_enctype, &kctx->kc_keyi,
1410 khdr, 3, data_desc, 0, NULL, &cksum))
1411 return GSS_S_FAILURE;
1412 LASSERT(cksum.len >= ke->ke_hash_size);
1415 * clear text layout for encryption:
1416 * -----------------------------------------
1417 * | confounder | clear msgs | krb5 header |
1418 * -----------------------------------------
1420 data_desc[0].data = conf;
1421 data_desc[0].len = ke->ke_conf_size;
1422 data_desc[1].data = msg->data;
1423 data_desc[1].len = msg->len;
1424 data_desc[2].data = (__u8 *) khdr;
1425 data_desc[2].len = sizeof(*khdr);
1427 /* cipher text will be directly inplace */
1428 cipher.data = (__u8 *) (khdr + 1);
1429 cipher.len = token->len - sizeof(*khdr);
1430 LASSERT(cipher.len >= ke->ke_conf_size + msg->len + sizeof(*khdr));
1432 if (kctx->kc_enctype == ENCTYPE_ARCFOUR_HMAC) {
1434 struct crypto_blkcipher *arc4_tfm;
1436 if (krb5_make_checksum(ENCTYPE_ARCFOUR_HMAC, &kctx->kc_keyi,
1437 NULL, 1, &cksum, 0, NULL, &arc4_keye)) {
1438 CERROR("failed to obtain arc4 enc key\n");
1439 GOTO(arc4_out, rc = -EACCES);
1442 arc4_tfm = crypto_alloc_blkcipher("ecb(arc4)", 0, 0);
1443 if (IS_ERR(arc4_tfm)) {
1444 CERROR("failed to alloc tfm arc4 in ECB mode\n");
1445 GOTO(arc4_out_key, rc = -EACCES);
1448 if (crypto_blkcipher_setkey(arc4_tfm, arc4_keye.data,
1450 CERROR("failed to set arc4 key, len %d\n",
1452 GOTO(arc4_out_tfm, rc = -EACCES);
1455 rc = krb5_encrypt_rawobjs(arc4_tfm, 1,
1456 3, data_desc, &cipher, 1);
1458 crypto_free_blkcipher(arc4_tfm);
1460 rawobj_free(&arc4_keye);
1462 do {} while(0); /* just to avoid compile warning */
1464 rc = krb5_encrypt_rawobjs(kctx->kc_keye.kb_tfm, 0,
1465 3, data_desc, &cipher, 1);
1469 rawobj_free(&cksum);
1470 return GSS_S_FAILURE;
1473 /* fill in checksum */
1474 LASSERT(token->len >= sizeof(*khdr) + cipher.len + ke->ke_hash_size);
1475 memcpy((char *)(khdr + 1) + cipher.len,
1476 cksum.data + cksum.len - ke->ke_hash_size,
1478 rawobj_free(&cksum);
1480 /* final token length */
1481 token->len = sizeof(*khdr) + cipher.len + ke->ke_hash_size;
1482 return GSS_S_COMPLETE;
1486 __u32 gss_prep_bulk_kerberos(struct gss_ctx *gctx,
1487 struct ptlrpc_bulk_desc *desc)
1489 struct krb5_ctx *kctx = gctx->internal_ctx_id;
1492 LASSERT(ptlrpc_is_bulk_desc_kiov(desc->bd_type));
1493 LASSERT(desc->bd_iov_count);
1494 LASSERT(GET_ENC_KIOV(desc));
1495 LASSERT(kctx->kc_keye.kb_tfm);
1497 blocksize = crypto_blkcipher_blocksize(kctx->kc_keye.kb_tfm);
1499 for (i = 0; i < desc->bd_iov_count; i++) {
1500 LASSERT(BD_GET_ENC_KIOV(desc, i).kiov_page);
1502 * offset should always start at page boundary of either
1503 * client or server side.
1505 if (BD_GET_KIOV(desc, i).kiov_offset & blocksize) {
1506 CERROR("odd offset %d in page %d\n",
1507 BD_GET_KIOV(desc, i).kiov_offset, i);
1508 return GSS_S_FAILURE;
1511 BD_GET_ENC_KIOV(desc, i).kiov_offset =
1512 BD_GET_KIOV(desc, i).kiov_offset;
1513 BD_GET_ENC_KIOV(desc, i).kiov_len =
1514 (BD_GET_KIOV(desc, i).kiov_len +
1515 blocksize - 1) & (~(blocksize - 1));
1518 return GSS_S_COMPLETE;
1522 __u32 gss_wrap_bulk_kerberos(struct gss_ctx *gctx,
1523 struct ptlrpc_bulk_desc *desc,
1524 rawobj_t *token, int adj_nob)
1526 struct krb5_ctx *kctx = gctx->internal_ctx_id;
1527 struct krb5_enctype *ke = &enctypes[kctx->kc_enctype];
1528 struct krb5_header *khdr;
1530 rawobj_t cksum = RAWOBJ_EMPTY;
1531 rawobj_t data_desc[1], cipher;
1532 __u8 conf[GSS_MAX_CIPHER_BLOCK];
1535 LASSERT(ptlrpc_is_bulk_desc_kiov(desc->bd_type));
1537 LASSERT(ke->ke_conf_size <= GSS_MAX_CIPHER_BLOCK);
1540 * final token format:
1541 * --------------------------------------------------
1542 * | krb5 header | head/tail cipher text | checksum |
1543 * --------------------------------------------------
1546 /* fill krb5 header */
1547 LASSERT(token->len >= sizeof(*khdr));
1548 khdr = (struct krb5_header *) token->data;
1549 fill_krb5_header(kctx, khdr, 1);
1551 /* generate confounder */
1552 cfs_get_random_bytes(conf, ke->ke_conf_size);
1554 /* get encryption blocksize. note kc_keye might not associated with
1555 * a tfm, currently only for arcfour-hmac */
1556 if (kctx->kc_enctype == ENCTYPE_ARCFOUR_HMAC) {
1557 LASSERT(kctx->kc_keye.kb_tfm == NULL);
1560 LASSERT(kctx->kc_keye.kb_tfm);
1561 blocksize = crypto_blkcipher_blocksize(kctx->kc_keye.kb_tfm);
1565 * we assume the size of krb5_header (16 bytes) must be n * blocksize.
1566 * the bulk token size would be exactly (sizeof(krb5_header) +
1567 * blocksize + sizeof(krb5_header) + hashsize)
1569 LASSERT(blocksize <= ke->ke_conf_size);
1570 LASSERT(sizeof(*khdr) >= blocksize && sizeof(*khdr) % blocksize == 0);
1571 LASSERT(token->len >= sizeof(*khdr) + blocksize + sizeof(*khdr) + 16);
1574 * clear text layout for checksum:
1575 * ------------------------------------------
1576 * | confounder | clear pages | krb5 header |
1577 * ------------------------------------------
1579 data_desc[0].data = conf;
1580 data_desc[0].len = ke->ke_conf_size;
1582 /* compute checksum */
1583 if (krb5_make_checksum(kctx->kc_enctype, &kctx->kc_keyi,
1585 desc->bd_iov_count, GET_KIOV(desc),
1587 return GSS_S_FAILURE;
1588 LASSERT(cksum.len >= ke->ke_hash_size);
1591 * clear text layout for encryption:
1592 * ------------------------------------------
1593 * | confounder | clear pages | krb5 header |
1594 * ------------------------------------------
1596 * ---------- (cipher pages) |
1598 * -------------------------------------------
1599 * | krb5 header | cipher text | cipher text |
1600 * -------------------------------------------
1602 data_desc[0].data = conf;
1603 data_desc[0].len = ke->ke_conf_size;
1605 cipher.data = (__u8 *) (khdr + 1);
1606 cipher.len = blocksize + sizeof(*khdr);
1608 if (kctx->kc_enctype == ENCTYPE_ARCFOUR_HMAC) {
1612 rc = krb5_encrypt_bulk(kctx->kc_keye.kb_tfm, khdr,
1613 conf, desc, &cipher, adj_nob);
1617 rawobj_free(&cksum);
1618 return GSS_S_FAILURE;
1621 /* fill in checksum */
1622 LASSERT(token->len >= sizeof(*khdr) + cipher.len + ke->ke_hash_size);
1623 memcpy((char *)(khdr + 1) + cipher.len,
1624 cksum.data + cksum.len - ke->ke_hash_size,
1626 rawobj_free(&cksum);
1628 /* final token length */
1629 token->len = sizeof(*khdr) + cipher.len + ke->ke_hash_size;
1630 return GSS_S_COMPLETE;
1634 __u32 gss_unwrap_kerberos(struct gss_ctx *gctx,
1639 struct krb5_ctx *kctx = gctx->internal_ctx_id;
1640 struct krb5_enctype *ke = &enctypes[kctx->kc_enctype];
1641 struct krb5_header *khdr;
1642 unsigned char *tmpbuf;
1643 int blocksize, bodysize;
1644 rawobj_t cksum = RAWOBJ_EMPTY;
1645 rawobj_t cipher_in, plain_out;
1646 rawobj_t hash_objs[3];
1652 if (token->len < sizeof(*khdr)) {
1653 CERROR("short signature: %u\n", token->len);
1654 return GSS_S_DEFECTIVE_TOKEN;
1657 khdr = (struct krb5_header *) token->data;
1659 major = verify_krb5_header(kctx, khdr, 1);
1660 if (major != GSS_S_COMPLETE) {
1661 CERROR("bad krb5 header\n");
1666 if (kctx->kc_enctype == ENCTYPE_ARCFOUR_HMAC) {
1667 LASSERT(kctx->kc_keye.kb_tfm == NULL);
1670 LASSERT(kctx->kc_keye.kb_tfm);
1671 blocksize = crypto_blkcipher_blocksize(kctx->kc_keye.kb_tfm);
1674 /* expected token layout:
1675 * ----------------------------------------
1676 * | krb5 header | cipher text | checksum |
1677 * ----------------------------------------
1679 bodysize = token->len - sizeof(*khdr) - ke->ke_hash_size;
1681 if (bodysize % blocksize) {
1682 CERROR("odd bodysize %d\n", bodysize);
1683 return GSS_S_DEFECTIVE_TOKEN;
1686 if (bodysize <= ke->ke_conf_size + sizeof(*khdr)) {
1687 CERROR("incomplete token: bodysize %d\n", bodysize);
1688 return GSS_S_DEFECTIVE_TOKEN;
1691 if (msg->len < bodysize - ke->ke_conf_size - sizeof(*khdr)) {
1692 CERROR("buffer too small: %u, require %d\n",
1693 msg->len, bodysize - ke->ke_conf_size);
1694 return GSS_S_FAILURE;
1698 OBD_ALLOC_LARGE(tmpbuf, bodysize);
1700 return GSS_S_FAILURE;
1702 major = GSS_S_FAILURE;
1704 cipher_in.data = (__u8 *) (khdr + 1);
1705 cipher_in.len = bodysize;
1706 plain_out.data = tmpbuf;
1707 plain_out.len = bodysize;
1709 if (kctx->kc_enctype == ENCTYPE_ARCFOUR_HMAC) {
1711 struct crypto_blkcipher *arc4_tfm;
1713 cksum.data = token->data + token->len - ke->ke_hash_size;
1714 cksum.len = ke->ke_hash_size;
1716 if (krb5_make_checksum(ENCTYPE_ARCFOUR_HMAC, &kctx->kc_keyi,
1717 NULL, 1, &cksum, 0, NULL, &arc4_keye)) {
1718 CERROR("failed to obtain arc4 enc key\n");
1719 GOTO(arc4_out, rc = -EACCES);
1722 arc4_tfm = crypto_alloc_blkcipher("ecb(arc4)", 0, 0);
1723 if (IS_ERR(arc4_tfm)) {
1724 CERROR("failed to alloc tfm arc4 in ECB mode\n");
1725 GOTO(arc4_out_key, rc = -EACCES);
1728 if (crypto_blkcipher_setkey(arc4_tfm,
1729 arc4_keye.data, arc4_keye.len)) {
1730 CERROR("failed to set arc4 key, len %d\n",
1732 GOTO(arc4_out_tfm, rc = -EACCES);
1735 rc = krb5_encrypt_rawobjs(arc4_tfm, 1,
1736 1, &cipher_in, &plain_out, 0);
1738 crypto_free_blkcipher(arc4_tfm);
1740 rawobj_free(&arc4_keye);
1742 cksum = RAWOBJ_EMPTY;
1744 rc = krb5_encrypt_rawobjs(kctx->kc_keye.kb_tfm, 0,
1745 1, &cipher_in, &plain_out, 0);
1749 CERROR("error decrypt\n");
1752 LASSERT(plain_out.len == bodysize);
1754 /* expected clear text layout:
1755 * -----------------------------------------
1756 * | confounder | clear msgs | krb5 header |
1757 * -----------------------------------------
1760 /* verify krb5 header in token is not modified */
1761 if (memcmp(khdr, plain_out.data + plain_out.len - sizeof(*khdr),
1763 CERROR("decrypted krb5 header mismatch\n");
1767 /* verify checksum, compose clear text as layout:
1768 * ------------------------------------------------------
1769 * | confounder | gss header | clear msgs | krb5 header |
1770 * ------------------------------------------------------
1772 hash_objs[0].len = ke->ke_conf_size;
1773 hash_objs[0].data = plain_out.data;
1774 hash_objs[1].len = gsshdr->len;
1775 hash_objs[1].data = gsshdr->data;
1776 hash_objs[2].len = plain_out.len - ke->ke_conf_size - sizeof(*khdr);
1777 hash_objs[2].data = plain_out.data + ke->ke_conf_size;
1778 if (krb5_make_checksum(kctx->kc_enctype, &kctx->kc_keyi,
1779 khdr, 3, hash_objs, 0, NULL, &cksum))
1782 LASSERT(cksum.len >= ke->ke_hash_size);
1783 if (memcmp((char *)(khdr + 1) + bodysize,
1784 cksum.data + cksum.len - ke->ke_hash_size,
1785 ke->ke_hash_size)) {
1786 CERROR("checksum mismatch\n");
1790 msg->len = bodysize - ke->ke_conf_size - sizeof(*khdr);
1791 memcpy(msg->data, tmpbuf + ke->ke_conf_size, msg->len);
1793 major = GSS_S_COMPLETE;
1795 OBD_FREE_LARGE(tmpbuf, bodysize);
1796 rawobj_free(&cksum);
1801 __u32 gss_unwrap_bulk_kerberos(struct gss_ctx *gctx,
1802 struct ptlrpc_bulk_desc *desc,
1803 rawobj_t *token, int adj_nob)
1805 struct krb5_ctx *kctx = gctx->internal_ctx_id;
1806 struct krb5_enctype *ke = &enctypes[kctx->kc_enctype];
1807 struct krb5_header *khdr;
1809 rawobj_t cksum = RAWOBJ_EMPTY;
1810 rawobj_t cipher, plain;
1811 rawobj_t data_desc[1];
1815 LASSERT(ptlrpc_is_bulk_desc_kiov(desc->bd_type));
1818 if (token->len < sizeof(*khdr)) {
1819 CERROR("short signature: %u\n", token->len);
1820 return GSS_S_DEFECTIVE_TOKEN;
1823 khdr = (struct krb5_header *) token->data;
1825 major = verify_krb5_header(kctx, khdr, 1);
1826 if (major != GSS_S_COMPLETE) {
1827 CERROR("bad krb5 header\n");
1832 if (kctx->kc_enctype == ENCTYPE_ARCFOUR_HMAC) {
1833 LASSERT(kctx->kc_keye.kb_tfm == NULL);
1837 LASSERT(kctx->kc_keye.kb_tfm);
1838 blocksize = crypto_blkcipher_blocksize(kctx->kc_keye.kb_tfm);
1840 LASSERT(sizeof(*khdr) >= blocksize && sizeof(*khdr) % blocksize == 0);
1843 * token format is expected as:
1844 * -----------------------------------------------
1845 * | krb5 header | head/tail cipher text | cksum |
1846 * -----------------------------------------------
1848 if (token->len < sizeof(*khdr) + blocksize + sizeof(*khdr) +
1850 CERROR("short token size: %u\n", token->len);
1851 return GSS_S_DEFECTIVE_TOKEN;
1854 cipher.data = (__u8 *) (khdr + 1);
1855 cipher.len = blocksize + sizeof(*khdr);
1856 plain.data = cipher.data;
1857 plain.len = cipher.len;
1859 rc = krb5_decrypt_bulk(kctx->kc_keye.kb_tfm, khdr,
1860 desc, &cipher, &plain, adj_nob);
1862 return GSS_S_DEFECTIVE_TOKEN;
1865 * verify checksum, compose clear text as layout:
1866 * ------------------------------------------
1867 * | confounder | clear pages | krb5 header |
1868 * ------------------------------------------
1870 data_desc[0].data = plain.data;
1871 data_desc[0].len = blocksize;
1873 if (krb5_make_checksum(kctx->kc_enctype, &kctx->kc_keyi,
1878 return GSS_S_FAILURE;
1879 LASSERT(cksum.len >= ke->ke_hash_size);
1881 if (memcmp(plain.data + blocksize + sizeof(*khdr),
1882 cksum.data + cksum.len - ke->ke_hash_size,
1883 ke->ke_hash_size)) {
1884 CERROR("checksum mismatch\n");
1885 rawobj_free(&cksum);
1886 return GSS_S_BAD_SIG;
1889 rawobj_free(&cksum);
1890 return GSS_S_COMPLETE;
1893 int gss_display_kerberos(struct gss_ctx *ctx,
1897 struct krb5_ctx *kctx = ctx->internal_ctx_id;
1900 written = snprintf(buf, bufsize, "krb5 (%s)",
1901 enctype2str(kctx->kc_enctype));
1905 static struct gss_api_ops gss_kerberos_ops = {
1906 .gss_import_sec_context = gss_import_sec_context_kerberos,
1907 .gss_copy_reverse_context = gss_copy_reverse_context_kerberos,
1908 .gss_inquire_context = gss_inquire_context_kerberos,
1909 .gss_get_mic = gss_get_mic_kerberos,
1910 .gss_verify_mic = gss_verify_mic_kerberos,
1911 .gss_wrap = gss_wrap_kerberos,
1912 .gss_unwrap = gss_unwrap_kerberos,
1913 .gss_prep_bulk = gss_prep_bulk_kerberos,
1914 .gss_wrap_bulk = gss_wrap_bulk_kerberos,
1915 .gss_unwrap_bulk = gss_unwrap_bulk_kerberos,
1916 .gss_delete_sec_context = gss_delete_sec_context_kerberos,
1917 .gss_display = gss_display_kerberos,
1920 static struct subflavor_desc gss_kerberos_sfs[] = {
1922 .sf_subflavor = SPTLRPC_SUBFLVR_KRB5N,
1924 .sf_service = SPTLRPC_SVC_NULL,
1928 .sf_subflavor = SPTLRPC_SUBFLVR_KRB5A,
1930 .sf_service = SPTLRPC_SVC_AUTH,
1934 .sf_subflavor = SPTLRPC_SUBFLVR_KRB5I,
1936 .sf_service = SPTLRPC_SVC_INTG,
1940 .sf_subflavor = SPTLRPC_SUBFLVR_KRB5P,
1942 .sf_service = SPTLRPC_SVC_PRIV,
1948 * currently we leave module owner NULL
1950 static struct gss_api_mech gss_kerberos_mech = {
1951 .gm_owner = NULL, /*THIS_MODULE, */
1953 .gm_oid = (rawobj_t)
1954 {9, "\052\206\110\206\367\022\001\002\002"},
1955 .gm_ops = &gss_kerberos_ops,
1957 .gm_sfs = gss_kerberos_sfs,
1960 int __init init_kerberos_module(void)
1964 spin_lock_init(&krb5_seq_lock);
1966 status = lgss_mech_register(&gss_kerberos_mech);
1968 CERROR("Failed to register kerberos gss mechanism!\n");
1972 void cleanup_kerberos_module(void)
1974 lgss_mech_unregister(&gss_kerberos_mech);