2 * Modifications for Lustre
4 * Copyright (c) 2007, 2010, Oracle and/or its affiliates. All rights reserved.
6 * Copyright (c) 2011, 2012, 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
= ll_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 (ll_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 ll_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
, "succesfully 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
, "succesfully 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
, "succesfully 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 void buf_to_sg(struct scatterlist
*sg
, void *ptr
, int len
)
528 sg_set_buf(sg
, ptr
, len
);
532 __u32
krb5_encrypt(struct ll_crypto_cipher
*tfm
,
539 struct blkcipher_desc desc
;
540 struct scatterlist sg
;
541 __u8 local_iv
[16] = {0};
546 desc
.info
= local_iv
;
549 if (length
% ll_crypto_blkcipher_blocksize(tfm
) != 0) {
550 CERROR("output length %d mismatch blocksize %d\n",
551 length
, ll_crypto_blkcipher_blocksize(tfm
));
555 if (ll_crypto_blkcipher_ivsize(tfm
) > 16) {
556 CERROR("iv size too large %d\n", ll_crypto_blkcipher_ivsize(tfm
));
561 memcpy(local_iv
, iv
, ll_crypto_blkcipher_ivsize(tfm
));
563 memcpy(out
, in
, length
);
564 buf_to_sg(&sg
, out
, length
);
567 ret
= ll_crypto_blkcipher_decrypt_iv(&desc
, &sg
, &sg
, length
);
569 ret
= ll_crypto_blkcipher_encrypt_iv(&desc
, &sg
, &sg
, length
);
577 int krb5_digest_hmac(struct ll_crypto_hash
*tfm
,
579 struct krb5_header
*khdr
,
580 int msgcnt
, rawobj_t
*msgs
,
581 int iovcnt
, lnet_kiov_t
*iovs
,
584 struct hash_desc desc
;
585 struct scatterlist sg
[1];
588 ll_crypto_hash_setkey(tfm
, key
->data
, key
->len
);
592 ll_crypto_hash_init(&desc
);
594 for (i
= 0; i
< msgcnt
; i
++) {
595 if (msgs
[i
].len
== 0)
597 buf_to_sg(sg
, (char *) msgs
[i
].data
, msgs
[i
].len
);
598 ll_crypto_hash_update(&desc
, sg
, msgs
[i
].len
);
601 for (i
= 0; i
< iovcnt
; i
++) {
602 if (iovs
[i
].kiov_len
== 0)
605 sg_set_page(&sg
[0], iovs
[i
].kiov_page
, iovs
[i
].kiov_len
,
606 iovs
[i
].kiov_offset
);
607 ll_crypto_hash_update(&desc
, sg
, iovs
[i
].kiov_len
);
611 buf_to_sg(sg
, (char *) khdr
, sizeof(*khdr
));
612 ll_crypto_hash_update(&desc
, sg
, sizeof(*khdr
));
615 return ll_crypto_hash_final(&desc
, cksum
->data
);
620 int krb5_digest_norm(struct ll_crypto_hash
*tfm
,
621 struct krb5_keyblock
*kb
,
622 struct krb5_header
*khdr
,
623 int msgcnt
, rawobj_t
*msgs
,
624 int iovcnt
, lnet_kiov_t
*iovs
,
627 struct hash_desc desc
;
628 struct scatterlist sg
[1];
635 ll_crypto_hash_init(&desc
);
637 for (i
= 0; i
< msgcnt
; i
++) {
638 if (msgs
[i
].len
== 0)
640 buf_to_sg(sg
, (char *) msgs
[i
].data
, msgs
[i
].len
);
641 ll_crypto_hash_update(&desc
, sg
, msgs
[i
].len
);
644 for (i
= 0; i
< iovcnt
; i
++) {
645 if (iovs
[i
].kiov_len
== 0)
648 sg_set_page(&sg
[0], iovs
[i
].kiov_page
, iovs
[i
].kiov_len
,
649 iovs
[i
].kiov_offset
);
650 ll_crypto_hash_update(&desc
, sg
, iovs
[i
].kiov_len
);
654 buf_to_sg(sg
, (char *) khdr
, sizeof(*khdr
));
655 ll_crypto_hash_update(&desc
, sg
, sizeof(*khdr
));
658 ll_crypto_hash_final(&desc
, cksum
->data
);
660 return krb5_encrypt(kb
->kb_tfm
, 0, NULL
, cksum
->data
,
661 cksum
->data
, cksum
->len
);
665 * compute (keyed/keyless) checksum against the plain text which appended
666 * with krb5 wire token header.
669 __s32
krb5_make_checksum(__u32 enctype
,
670 struct krb5_keyblock
*kb
,
671 struct krb5_header
*khdr
,
672 int msgcnt
, rawobj_t
*msgs
,
673 int iovcnt
, lnet_kiov_t
*iovs
,
676 struct krb5_enctype
*ke
= &enctypes
[enctype
];
677 struct ll_crypto_hash
*tfm
;
678 __u32 code
= GSS_S_FAILURE
;
681 if (!(tfm
= ll_crypto_alloc_hash(ke
->ke_hash_name
, 0, 0))) {
682 CERROR("failed to alloc TFM: %s\n", ke
->ke_hash_name
);
683 return GSS_S_FAILURE
;
686 cksum
->len
= ll_crypto_hash_digestsize(tfm
);
687 OBD_ALLOC_LARGE(cksum
->data
, cksum
->len
);
693 if (ke
->ke_hash_hmac
)
694 rc
= krb5_digest_hmac(tfm
, &kb
->kb_key
,
695 khdr
, msgcnt
, msgs
, iovcnt
, iovs
, cksum
);
697 rc
= krb5_digest_norm(tfm
, kb
,
698 khdr
, msgcnt
, msgs
, iovcnt
, iovs
, cksum
);
701 code
= GSS_S_COMPLETE
;
703 ll_crypto_free_hash(tfm
);
707 static void fill_krb5_header(struct krb5_ctx
*kctx
,
708 struct krb5_header
*khdr
,
711 unsigned char acceptor_flag
;
713 acceptor_flag
= kctx
->kc_initiate
? 0 : FLAG_SENDER_IS_ACCEPTOR
;
716 khdr
->kh_tok_id
= cpu_to_be16(KG_TOK_WRAP_MSG
);
717 khdr
->kh_flags
= acceptor_flag
| FLAG_WRAP_CONFIDENTIAL
;
718 khdr
->kh_ec
= cpu_to_be16(0);
719 khdr
->kh_rrc
= cpu_to_be16(0);
721 khdr
->kh_tok_id
= cpu_to_be16(KG_TOK_MIC_MSG
);
722 khdr
->kh_flags
= acceptor_flag
;
723 khdr
->kh_ec
= cpu_to_be16(0xffff);
724 khdr
->kh_rrc
= cpu_to_be16(0xffff);
727 khdr
->kh_filler
= 0xff;
728 spin_lock(&krb5_seq_lock
);
729 khdr
->kh_seq
= cpu_to_be64(kctx
->kc_seq_send
++);
730 spin_unlock(&krb5_seq_lock
);
733 static __u32
verify_krb5_header(struct krb5_ctx
*kctx
,
734 struct krb5_header
*khdr
,
737 unsigned char acceptor_flag
;
738 __u16 tok_id
, ec_rrc
;
740 acceptor_flag
= kctx
->kc_initiate
? FLAG_SENDER_IS_ACCEPTOR
: 0;
743 tok_id
= KG_TOK_WRAP_MSG
;
746 tok_id
= KG_TOK_MIC_MSG
;
751 if (be16_to_cpu(khdr
->kh_tok_id
) != tok_id
) {
752 CERROR("bad token id\n");
753 return GSS_S_DEFECTIVE_TOKEN
;
755 if ((khdr
->kh_flags
& FLAG_SENDER_IS_ACCEPTOR
) != acceptor_flag
) {
756 CERROR("bad direction flag\n");
757 return GSS_S_BAD_SIG
;
759 if (privacy
&& (khdr
->kh_flags
& FLAG_WRAP_CONFIDENTIAL
) == 0) {
760 CERROR("missing confidential flag\n");
761 return GSS_S_BAD_SIG
;
763 if (khdr
->kh_filler
!= 0xff) {
764 CERROR("bad filler\n");
765 return GSS_S_DEFECTIVE_TOKEN
;
767 if (be16_to_cpu(khdr
->kh_ec
) != ec_rrc
||
768 be16_to_cpu(khdr
->kh_rrc
) != ec_rrc
) {
769 CERROR("bad EC or RRC\n");
770 return GSS_S_DEFECTIVE_TOKEN
;
772 return GSS_S_COMPLETE
;
776 __u32
gss_get_mic_kerberos(struct gss_ctx
*gctx
,
783 struct krb5_ctx
*kctx
= gctx
->internal_ctx_id
;
784 struct krb5_enctype
*ke
= &enctypes
[kctx
->kc_enctype
];
785 struct krb5_header
*khdr
;
786 rawobj_t cksum
= RAWOBJ_EMPTY
;
788 /* fill krb5 header */
789 LASSERT(token
->len
>= sizeof(*khdr
));
790 khdr
= (struct krb5_header
*) token
->data
;
791 fill_krb5_header(kctx
, khdr
, 0);
794 if (krb5_make_checksum(kctx
->kc_enctype
, &kctx
->kc_keyc
,
795 khdr
, msgcnt
, msgs
, iovcnt
, iovs
, &cksum
))
796 return GSS_S_FAILURE
;
798 LASSERT(cksum
.len
>= ke
->ke_hash_size
);
799 LASSERT(token
->len
>= sizeof(*khdr
) + ke
->ke_hash_size
);
800 memcpy(khdr
+ 1, cksum
.data
+ cksum
.len
- ke
->ke_hash_size
,
803 token
->len
= sizeof(*khdr
) + ke
->ke_hash_size
;
805 return GSS_S_COMPLETE
;
809 __u32
gss_verify_mic_kerberos(struct gss_ctx
*gctx
,
816 struct krb5_ctx
*kctx
= gctx
->internal_ctx_id
;
817 struct krb5_enctype
*ke
= &enctypes
[kctx
->kc_enctype
];
818 struct krb5_header
*khdr
;
819 rawobj_t cksum
= RAWOBJ_EMPTY
;
822 if (token
->len
< sizeof(*khdr
)) {
823 CERROR("short signature: %u\n", token
->len
);
824 return GSS_S_DEFECTIVE_TOKEN
;
827 khdr
= (struct krb5_header
*) token
->data
;
829 major
= verify_krb5_header(kctx
, khdr
, 0);
830 if (major
!= GSS_S_COMPLETE
) {
831 CERROR("bad krb5 header\n");
835 if (token
->len
< sizeof(*khdr
) + ke
->ke_hash_size
) {
836 CERROR("short signature: %u, require %d\n",
837 token
->len
, (int) sizeof(*khdr
) + ke
->ke_hash_size
);
838 return GSS_S_FAILURE
;
841 if (krb5_make_checksum(kctx
->kc_enctype
, &kctx
->kc_keyc
,
842 khdr
, msgcnt
, msgs
, iovcnt
, iovs
, &cksum
)) {
843 CERROR("failed to make checksum\n");
844 return GSS_S_FAILURE
;
847 LASSERT(cksum
.len
>= ke
->ke_hash_size
);
848 if (memcmp(khdr
+ 1, cksum
.data
+ cksum
.len
- ke
->ke_hash_size
,
850 CERROR("checksum mismatch\n");
852 return GSS_S_BAD_SIG
;
856 return GSS_S_COMPLETE
;
860 int add_padding(rawobj_t
*msg
, int msg_buflen
, int blocksize
)
864 padding
= (blocksize
- (msg
->len
& (blocksize
- 1))) &
869 if (msg
->len
+ padding
> msg_buflen
) {
870 CERROR("bufsize %u too small: datalen %u, padding %u\n",
871 msg_buflen
, msg
->len
, padding
);
875 memset(msg
->data
+ msg
->len
, padding
, padding
);
881 int krb5_encrypt_rawobjs(struct ll_crypto_cipher
*tfm
,
888 struct blkcipher_desc desc
;
889 struct scatterlist src
, dst
;
890 __u8 local_iv
[16] = {0}, *buf
;
897 desc
.info
= local_iv
;
900 for (i
= 0; i
< inobj_cnt
; i
++) {
901 LASSERT(buf
+ inobjs
[i
].len
<= outobj
->data
+ outobj
->len
);
903 buf_to_sg(&src
, inobjs
[i
].data
, inobjs
[i
].len
);
904 buf_to_sg(&dst
, buf
, outobj
->len
- datalen
);
908 rc
= ll_crypto_blkcipher_encrypt(
909 &desc
, &dst
, &src
, src
.length
);
911 rc
= ll_crypto_blkcipher_decrypt(
912 &desc
, &dst
, &src
, src
.length
);
915 rc
= ll_crypto_blkcipher_encrypt_iv(
916 &desc
, &dst
, &src
, src
.length
);
918 rc
= ll_crypto_blkcipher_decrypt_iv(
919 &desc
, &dst
, &src
, src
.length
);
923 CERROR("encrypt error %d\n", rc
);
927 datalen
+= inobjs
[i
].len
;
928 buf
+= inobjs
[i
].len
;
931 outobj
->len
= datalen
;
936 * if adj_nob != 0, we adjust desc->bd_nob to the actual cipher text size.
939 int krb5_encrypt_bulk(struct ll_crypto_cipher
*tfm
,
940 struct krb5_header
*khdr
,
942 struct ptlrpc_bulk_desc
*desc
,
946 struct blkcipher_desc ciph_desc
;
947 __u8 local_iv
[16] = {0};
948 struct scatterlist src
, dst
;
949 int blocksize
, i
, rc
, nob
= 0;
951 LASSERT(desc
->bd_iov_count
);
952 LASSERT(desc
->bd_enc_iov
);
954 blocksize
= ll_crypto_blkcipher_blocksize(tfm
);
955 LASSERT(blocksize
> 1);
956 LASSERT(cipher
->len
== blocksize
+ sizeof(*khdr
));
959 ciph_desc
.info
= local_iv
;
962 /* encrypt confounder */
963 buf_to_sg(&src
, confounder
, blocksize
);
964 buf_to_sg(&dst
, cipher
->data
, blocksize
);
966 rc
= ll_crypto_blkcipher_encrypt_iv(&ciph_desc
, &dst
, &src
, blocksize
);
968 CERROR("error to encrypt confounder: %d\n", rc
);
972 /* encrypt clear pages */
973 for (i
= 0; i
< desc
->bd_iov_count
; i
++) {
974 sg_set_page(&src
, desc
->bd_iov
[i
].kiov_page
,
975 (desc
->bd_iov
[i
].kiov_len
+ blocksize
- 1) &
977 desc
->bd_iov
[i
].kiov_offset
);
980 sg_set_page(&dst
, desc
->bd_enc_iov
[i
].kiov_page
, src
.length
,
983 desc
->bd_enc_iov
[i
].kiov_offset
= dst
.offset
;
984 desc
->bd_enc_iov
[i
].kiov_len
= dst
.length
;
986 rc
= ll_crypto_blkcipher_encrypt_iv(&ciph_desc
, &dst
, &src
,
989 CERROR("error to encrypt page: %d\n", rc
);
994 /* encrypt krb5 header */
995 buf_to_sg(&src
, khdr
, sizeof(*khdr
));
996 buf_to_sg(&dst
, cipher
->data
+ blocksize
, sizeof(*khdr
));
998 rc
= ll_crypto_blkcipher_encrypt_iv(&ciph_desc
,
999 &dst
, &src
, sizeof(*khdr
));
1001 CERROR("error to encrypt krb5 header: %d\n", rc
);
1012 * desc->bd_nob_transferred is the size of cipher text received.
1013 * desc->bd_nob is the target size of plain text supposed to be.
1015 * if adj_nob != 0, we adjust each page's kiov_len to the actual
1017 * - for client read: we don't know data size for each page, so
1018 * bd_iov[]->kiov_len is set to PAGE_SIZE, but actual data received might
1019 * be smaller, so we need to adjust it according to bd_enc_iov[]->kiov_len.
1020 * this means we DO NOT support the situation that server send an odd size
1021 * data in a page which is not the last one.
1022 * - for server write: we knows exactly data size for each page being expected,
1023 * thus kiov_len is accurate already, so we should not adjust it at all.
1024 * and bd_enc_iov[]->kiov_len should be round_up(bd_iov[]->kiov_len) which
1025 * should have been done by prep_bulk().
1028 int krb5_decrypt_bulk(struct ll_crypto_cipher
*tfm
,
1029 struct krb5_header
*khdr
,
1030 struct ptlrpc_bulk_desc
*desc
,
1035 struct blkcipher_desc ciph_desc
;
1036 __u8 local_iv
[16] = {0};
1037 struct scatterlist src
, dst
;
1038 int ct_nob
= 0, pt_nob
= 0;
1039 int blocksize
, i
, rc
;
1041 LASSERT(desc
->bd_iov_count
);
1042 LASSERT(desc
->bd_enc_iov
);
1043 LASSERT(desc
->bd_nob_transferred
);
1045 blocksize
= ll_crypto_blkcipher_blocksize(tfm
);
1046 LASSERT(blocksize
> 1);
1047 LASSERT(cipher
->len
== blocksize
+ sizeof(*khdr
));
1049 ciph_desc
.tfm
= tfm
;
1050 ciph_desc
.info
= local_iv
;
1051 ciph_desc
.flags
= 0;
1053 if (desc
->bd_nob_transferred
% blocksize
) {
1054 CERROR("odd transferred nob: %d\n", desc
->bd_nob_transferred
);
1058 /* decrypt head (confounder) */
1059 buf_to_sg(&src
, cipher
->data
, blocksize
);
1060 buf_to_sg(&dst
, plain
->data
, blocksize
);
1062 rc
= ll_crypto_blkcipher_decrypt_iv(&ciph_desc
, &dst
, &src
, blocksize
);
1064 CERROR("error to decrypt confounder: %d\n", rc
);
1068 for (i
= 0; i
< desc
->bd_iov_count
&& ct_nob
< desc
->bd_nob_transferred
;
1070 if (desc
->bd_enc_iov
[i
].kiov_offset
% blocksize
!= 0 ||
1071 desc
->bd_enc_iov
[i
].kiov_len
% blocksize
!= 0) {
1072 CERROR("page %d: odd offset %u len %u, blocksize %d\n",
1073 i
, desc
->bd_enc_iov
[i
].kiov_offset
,
1074 desc
->bd_enc_iov
[i
].kiov_len
, blocksize
);
1079 if (ct_nob
+ desc
->bd_enc_iov
[i
].kiov_len
>
1080 desc
->bd_nob_transferred
)
1081 desc
->bd_enc_iov
[i
].kiov_len
=
1082 desc
->bd_nob_transferred
- ct_nob
;
1084 desc
->bd_iov
[i
].kiov_len
= desc
->bd_enc_iov
[i
].kiov_len
;
1085 if (pt_nob
+ desc
->bd_enc_iov
[i
].kiov_len
>desc
->bd_nob
)
1086 desc
->bd_iov
[i
].kiov_len
= desc
->bd_nob
-pt_nob
;
1088 /* this should be guaranteed by LNET */
1089 LASSERT(ct_nob
+ desc
->bd_enc_iov
[i
].kiov_len
<=
1090 desc
->bd_nob_transferred
);
1091 LASSERT(desc
->bd_iov
[i
].kiov_len
<=
1092 desc
->bd_enc_iov
[i
].kiov_len
);
1095 if (desc
->bd_enc_iov
[i
].kiov_len
== 0)
1098 sg_set_page(&src
, desc
->bd_enc_iov
[i
].kiov_page
,
1099 desc
->bd_enc_iov
[i
].kiov_len
,
1100 desc
->bd_enc_iov
[i
].kiov_offset
);
1102 if (desc
->bd_iov
[i
].kiov_len
% blocksize
== 0)
1103 sg_assign_page(&dst
, desc
->bd_iov
[i
].kiov_page
);
1105 rc
= ll_crypto_blkcipher_decrypt_iv(&ciph_desc
, &dst
, &src
,
1108 CERROR("error to decrypt page: %d\n", rc
);
1112 if (desc
->bd_iov
[i
].kiov_len
% blocksize
!= 0) {
1113 memcpy(page_address(desc
->bd_iov
[i
].kiov_page
) +
1114 desc
->bd_iov
[i
].kiov_offset
,
1115 page_address(desc
->bd_enc_iov
[i
].kiov_page
) +
1116 desc
->bd_iov
[i
].kiov_offset
,
1117 desc
->bd_iov
[i
].kiov_len
);
1120 ct_nob
+= desc
->bd_enc_iov
[i
].kiov_len
;
1121 pt_nob
+= desc
->bd_iov
[i
].kiov_len
;
1124 if (unlikely(ct_nob
!= desc
->bd_nob_transferred
)) {
1125 CERROR("%d cipher text transferred but only %d decrypted\n",
1126 desc
->bd_nob_transferred
, ct_nob
);
1130 if (unlikely(!adj_nob
&& pt_nob
!= desc
->bd_nob
)) {
1131 CERROR("%d plain text expected but only %d received\n",
1132 desc
->bd_nob
, pt_nob
);
1136 /* if needed, clear up the rest unused iovs */
1138 while (i
< desc
->bd_iov_count
)
1139 desc
->bd_iov
[i
++].kiov_len
= 0;
1141 /* decrypt tail (krb5 header) */
1142 buf_to_sg(&src
, cipher
->data
+ blocksize
, sizeof(*khdr
));
1143 buf_to_sg(&dst
, cipher
->data
+ blocksize
, sizeof(*khdr
));
1145 rc
= ll_crypto_blkcipher_decrypt_iv(&ciph_desc
,
1146 &dst
, &src
, sizeof(*khdr
));
1148 CERROR("error to decrypt tail: %d\n", rc
);
1152 if (memcmp(cipher
->data
+ blocksize
, khdr
, sizeof(*khdr
))) {
1153 CERROR("krb5 header doesn't match\n");
1161 __u32
gss_wrap_kerberos(struct gss_ctx
*gctx
,
1167 struct krb5_ctx
*kctx
= gctx
->internal_ctx_id
;
1168 struct krb5_enctype
*ke
= &enctypes
[kctx
->kc_enctype
];
1169 struct krb5_header
*khdr
;
1171 rawobj_t cksum
= RAWOBJ_EMPTY
;
1172 rawobj_t data_desc
[3], cipher
;
1173 __u8 conf
[GSS_MAX_CIPHER_BLOCK
];
1177 LASSERT(ke
->ke_conf_size
<= GSS_MAX_CIPHER_BLOCK
);
1178 LASSERT(kctx
->kc_keye
.kb_tfm
== NULL
||
1180 ll_crypto_blkcipher_blocksize(kctx
->kc_keye
.kb_tfm
));
1183 * final token format:
1184 * ---------------------------------------------------
1185 * | krb5 header | cipher text | checksum (16 bytes) |
1186 * ---------------------------------------------------
1189 /* fill krb5 header */
1190 LASSERT(token
->len
>= sizeof(*khdr
));
1191 khdr
= (struct krb5_header
*) token
->data
;
1192 fill_krb5_header(kctx
, khdr
, 1);
1194 /* generate confounder */
1195 cfs_get_random_bytes(conf
, ke
->ke_conf_size
);
1197 /* get encryption blocksize. note kc_keye might not associated with
1198 * a tfm, currently only for arcfour-hmac */
1199 if (kctx
->kc_enctype
== ENCTYPE_ARCFOUR_HMAC
) {
1200 LASSERT(kctx
->kc_keye
.kb_tfm
== NULL
);
1203 LASSERT(kctx
->kc_keye
.kb_tfm
);
1204 blocksize
= ll_crypto_blkcipher_blocksize(kctx
->kc_keye
.kb_tfm
);
1206 LASSERT(blocksize
<= ke
->ke_conf_size
);
1208 /* padding the message */
1209 if (add_padding(msg
, msg_buflen
, blocksize
))
1210 return GSS_S_FAILURE
;
1213 * clear text layout for checksum:
1214 * ------------------------------------------------------
1215 * | confounder | gss header | clear msgs | krb5 header |
1216 * ------------------------------------------------------
1218 data_desc
[0].data
= conf
;
1219 data_desc
[0].len
= ke
->ke_conf_size
;
1220 data_desc
[1].data
= gsshdr
->data
;
1221 data_desc
[1].len
= gsshdr
->len
;
1222 data_desc
[2].data
= msg
->data
;
1223 data_desc
[2].len
= msg
->len
;
1225 /* compute checksum */
1226 if (krb5_make_checksum(kctx
->kc_enctype
, &kctx
->kc_keyi
,
1227 khdr
, 3, data_desc
, 0, NULL
, &cksum
))
1228 return GSS_S_FAILURE
;
1229 LASSERT(cksum
.len
>= ke
->ke_hash_size
);
1232 * clear text layout for encryption:
1233 * -----------------------------------------
1234 * | confounder | clear msgs | krb5 header |
1235 * -----------------------------------------
1237 data_desc
[0].data
= conf
;
1238 data_desc
[0].len
= ke
->ke_conf_size
;
1239 data_desc
[1].data
= msg
->data
;
1240 data_desc
[1].len
= msg
->len
;
1241 data_desc
[2].data
= (__u8
*) khdr
;
1242 data_desc
[2].len
= sizeof(*khdr
);
1244 /* cipher text will be directly inplace */
1245 cipher
.data
= (__u8
*) (khdr
+ 1);
1246 cipher
.len
= token
->len
- sizeof(*khdr
);
1247 LASSERT(cipher
.len
>= ke
->ke_conf_size
+ msg
->len
+ sizeof(*khdr
));
1249 if (kctx
->kc_enctype
== ENCTYPE_ARCFOUR_HMAC
) {
1251 struct ll_crypto_cipher
*arc4_tfm
;
1253 if (krb5_make_checksum(ENCTYPE_ARCFOUR_HMAC
, &kctx
->kc_keyi
,
1254 NULL
, 1, &cksum
, 0, NULL
, &arc4_keye
)) {
1255 CERROR("failed to obtain arc4 enc key\n");
1256 GOTO(arc4_out
, rc
= -EACCES
);
1259 arc4_tfm
= ll_crypto_alloc_blkcipher("ecb(arc4)", 0, 0);
1260 if (IS_ERR(arc4_tfm
)) {
1261 CERROR("failed to alloc tfm arc4 in ECB mode\n");
1262 GOTO(arc4_out_key
, rc
= -EACCES
);
1265 if (ll_crypto_blkcipher_setkey(arc4_tfm
, arc4_keye
.data
,
1267 CERROR("failed to set arc4 key, len %d\n",
1269 GOTO(arc4_out_tfm
, rc
= -EACCES
);
1272 rc
= krb5_encrypt_rawobjs(arc4_tfm
, 1,
1273 3, data_desc
, &cipher
, 1);
1275 ll_crypto_free_blkcipher(arc4_tfm
);
1277 rawobj_free(&arc4_keye
);
1279 do {} while(0); /* just to avoid compile warning */
1281 rc
= krb5_encrypt_rawobjs(kctx
->kc_keye
.kb_tfm
, 0,
1282 3, data_desc
, &cipher
, 1);
1286 rawobj_free(&cksum
);
1287 return GSS_S_FAILURE
;
1290 /* fill in checksum */
1291 LASSERT(token
->len
>= sizeof(*khdr
) + cipher
.len
+ ke
->ke_hash_size
);
1292 memcpy((char *)(khdr
+ 1) + cipher
.len
,
1293 cksum
.data
+ cksum
.len
- ke
->ke_hash_size
,
1295 rawobj_free(&cksum
);
1297 /* final token length */
1298 token
->len
= sizeof(*khdr
) + cipher
.len
+ ke
->ke_hash_size
;
1299 return GSS_S_COMPLETE
;
1303 __u32
gss_prep_bulk_kerberos(struct gss_ctx
*gctx
,
1304 struct ptlrpc_bulk_desc
*desc
)
1306 struct krb5_ctx
*kctx
= gctx
->internal_ctx_id
;
1309 LASSERT(desc
->bd_iov_count
);
1310 LASSERT(desc
->bd_enc_iov
);
1311 LASSERT(kctx
->kc_keye
.kb_tfm
);
1313 blocksize
= ll_crypto_blkcipher_blocksize(kctx
->kc_keye
.kb_tfm
);
1315 for (i
= 0; i
< desc
->bd_iov_count
; i
++) {
1316 LASSERT(desc
->bd_enc_iov
[i
].kiov_page
);
1318 * offset should always start at page boundary of either
1319 * client or server side.
1321 if (desc
->bd_iov
[i
].kiov_offset
& blocksize
) {
1322 CERROR("odd offset %d in page %d\n",
1323 desc
->bd_iov
[i
].kiov_offset
, i
);
1324 return GSS_S_FAILURE
;
1327 desc
->bd_enc_iov
[i
].kiov_offset
= desc
->bd_iov
[i
].kiov_offset
;
1328 desc
->bd_enc_iov
[i
].kiov_len
= (desc
->bd_iov
[i
].kiov_len
+
1329 blocksize
- 1) & (~(blocksize
- 1));
1332 return GSS_S_COMPLETE
;
1336 __u32
gss_wrap_bulk_kerberos(struct gss_ctx
*gctx
,
1337 struct ptlrpc_bulk_desc
*desc
,
1338 rawobj_t
*token
, int adj_nob
)
1340 struct krb5_ctx
*kctx
= gctx
->internal_ctx_id
;
1341 struct krb5_enctype
*ke
= &enctypes
[kctx
->kc_enctype
];
1342 struct krb5_header
*khdr
;
1344 rawobj_t cksum
= RAWOBJ_EMPTY
;
1345 rawobj_t data_desc
[1], cipher
;
1346 __u8 conf
[GSS_MAX_CIPHER_BLOCK
];
1350 LASSERT(ke
->ke_conf_size
<= GSS_MAX_CIPHER_BLOCK
);
1353 * final token format:
1354 * --------------------------------------------------
1355 * | krb5 header | head/tail cipher text | checksum |
1356 * --------------------------------------------------
1359 /* fill krb5 header */
1360 LASSERT(token
->len
>= sizeof(*khdr
));
1361 khdr
= (struct krb5_header
*) token
->data
;
1362 fill_krb5_header(kctx
, khdr
, 1);
1364 /* generate confounder */
1365 cfs_get_random_bytes(conf
, ke
->ke_conf_size
);
1367 /* get encryption blocksize. note kc_keye might not associated with
1368 * a tfm, currently only for arcfour-hmac */
1369 if (kctx
->kc_enctype
== ENCTYPE_ARCFOUR_HMAC
) {
1370 LASSERT(kctx
->kc_keye
.kb_tfm
== NULL
);
1373 LASSERT(kctx
->kc_keye
.kb_tfm
);
1374 blocksize
= ll_crypto_blkcipher_blocksize(kctx
->kc_keye
.kb_tfm
);
1378 * we assume the size of krb5_header (16 bytes) must be n * blocksize.
1379 * the bulk token size would be exactly (sizeof(krb5_header) +
1380 * blocksize + sizeof(krb5_header) + hashsize)
1382 LASSERT(blocksize
<= ke
->ke_conf_size
);
1383 LASSERT(sizeof(*khdr
) >= blocksize
&& sizeof(*khdr
) % blocksize
== 0);
1384 LASSERT(token
->len
>= sizeof(*khdr
) + blocksize
+ sizeof(*khdr
) + 16);
1387 * clear text layout for checksum:
1388 * ------------------------------------------
1389 * | confounder | clear pages | krb5 header |
1390 * ------------------------------------------
1392 data_desc
[0].data
= conf
;
1393 data_desc
[0].len
= ke
->ke_conf_size
;
1395 /* compute checksum */
1396 if (krb5_make_checksum(kctx
->kc_enctype
, &kctx
->kc_keyi
,
1398 desc
->bd_iov_count
, desc
->bd_iov
,
1400 return GSS_S_FAILURE
;
1401 LASSERT(cksum
.len
>= ke
->ke_hash_size
);
1404 * clear text layout for encryption:
1405 * ------------------------------------------
1406 * | confounder | clear pages | krb5 header |
1407 * ------------------------------------------
1409 * ---------- (cipher pages) |
1411 * -------------------------------------------
1412 * | krb5 header | cipher text | cipher text |
1413 * -------------------------------------------
1415 data_desc
[0].data
= conf
;
1416 data_desc
[0].len
= ke
->ke_conf_size
;
1418 cipher
.data
= (__u8
*) (khdr
+ 1);
1419 cipher
.len
= blocksize
+ sizeof(*khdr
);
1421 if (kctx
->kc_enctype
== ENCTYPE_ARCFOUR_HMAC
) {
1425 rc
= krb5_encrypt_bulk(kctx
->kc_keye
.kb_tfm
, khdr
,
1426 conf
, desc
, &cipher
, adj_nob
);
1430 rawobj_free(&cksum
);
1431 return GSS_S_FAILURE
;
1434 /* fill in checksum */
1435 LASSERT(token
->len
>= sizeof(*khdr
) + cipher
.len
+ ke
->ke_hash_size
);
1436 memcpy((char *)(khdr
+ 1) + cipher
.len
,
1437 cksum
.data
+ cksum
.len
- ke
->ke_hash_size
,
1439 rawobj_free(&cksum
);
1441 /* final token length */
1442 token
->len
= sizeof(*khdr
) + cipher
.len
+ ke
->ke_hash_size
;
1443 return GSS_S_COMPLETE
;
1447 __u32
gss_unwrap_kerberos(struct gss_ctx
*gctx
,
1452 struct krb5_ctx
*kctx
= gctx
->internal_ctx_id
;
1453 struct krb5_enctype
*ke
= &enctypes
[kctx
->kc_enctype
];
1454 struct krb5_header
*khdr
;
1455 unsigned char *tmpbuf
;
1456 int blocksize
, bodysize
;
1457 rawobj_t cksum
= RAWOBJ_EMPTY
;
1458 rawobj_t cipher_in
, plain_out
;
1459 rawobj_t hash_objs
[3];
1465 if (token
->len
< sizeof(*khdr
)) {
1466 CERROR("short signature: %u\n", token
->len
);
1467 return GSS_S_DEFECTIVE_TOKEN
;
1470 khdr
= (struct krb5_header
*) token
->data
;
1472 major
= verify_krb5_header(kctx
, khdr
, 1);
1473 if (major
!= GSS_S_COMPLETE
) {
1474 CERROR("bad krb5 header\n");
1479 if (kctx
->kc_enctype
== ENCTYPE_ARCFOUR_HMAC
) {
1480 LASSERT(kctx
->kc_keye
.kb_tfm
== NULL
);
1483 LASSERT(kctx
->kc_keye
.kb_tfm
);
1484 blocksize
= ll_crypto_blkcipher_blocksize(kctx
->kc_keye
.kb_tfm
);
1487 /* expected token layout:
1488 * ----------------------------------------
1489 * | krb5 header | cipher text | checksum |
1490 * ----------------------------------------
1492 bodysize
= token
->len
- sizeof(*khdr
) - ke
->ke_hash_size
;
1494 if (bodysize
% blocksize
) {
1495 CERROR("odd bodysize %d\n", bodysize
);
1496 return GSS_S_DEFECTIVE_TOKEN
;
1499 if (bodysize
<= ke
->ke_conf_size
+ sizeof(*khdr
)) {
1500 CERROR("incomplete token: bodysize %d\n", bodysize
);
1501 return GSS_S_DEFECTIVE_TOKEN
;
1504 if (msg
->len
< bodysize
- ke
->ke_conf_size
- sizeof(*khdr
)) {
1505 CERROR("buffer too small: %u, require %d\n",
1506 msg
->len
, bodysize
- ke
->ke_conf_size
);
1507 return GSS_S_FAILURE
;
1511 OBD_ALLOC_LARGE(tmpbuf
, bodysize
);
1513 return GSS_S_FAILURE
;
1515 major
= GSS_S_FAILURE
;
1517 cipher_in
.data
= (__u8
*) (khdr
+ 1);
1518 cipher_in
.len
= bodysize
;
1519 plain_out
.data
= tmpbuf
;
1520 plain_out
.len
= bodysize
;
1522 if (kctx
->kc_enctype
== ENCTYPE_ARCFOUR_HMAC
) {
1524 struct ll_crypto_cipher
*arc4_tfm
;
1526 cksum
.data
= token
->data
+ token
->len
- ke
->ke_hash_size
;
1527 cksum
.len
= ke
->ke_hash_size
;
1529 if (krb5_make_checksum(ENCTYPE_ARCFOUR_HMAC
, &kctx
->kc_keyi
,
1530 NULL
, 1, &cksum
, 0, NULL
, &arc4_keye
)) {
1531 CERROR("failed to obtain arc4 enc key\n");
1532 GOTO(arc4_out
, rc
= -EACCES
);
1535 arc4_tfm
= ll_crypto_alloc_blkcipher("ecb(arc4)", 0, 0);
1536 if (IS_ERR(arc4_tfm
)) {
1537 CERROR("failed to alloc tfm arc4 in ECB mode\n");
1538 GOTO(arc4_out_key
, rc
= -EACCES
);
1541 if (ll_crypto_blkcipher_setkey(arc4_tfm
,
1542 arc4_keye
.data
, arc4_keye
.len
)) {
1543 CERROR("failed to set arc4 key, len %d\n",
1545 GOTO(arc4_out_tfm
, rc
= -EACCES
);
1548 rc
= krb5_encrypt_rawobjs(arc4_tfm
, 1,
1549 1, &cipher_in
, &plain_out
, 0);
1551 ll_crypto_free_blkcipher(arc4_tfm
);
1553 rawobj_free(&arc4_keye
);
1555 cksum
= RAWOBJ_EMPTY
;
1557 rc
= krb5_encrypt_rawobjs(kctx
->kc_keye
.kb_tfm
, 0,
1558 1, &cipher_in
, &plain_out
, 0);
1562 CERROR("error decrypt\n");
1565 LASSERT(plain_out
.len
== bodysize
);
1567 /* expected clear text layout:
1568 * -----------------------------------------
1569 * | confounder | clear msgs | krb5 header |
1570 * -----------------------------------------
1573 /* verify krb5 header in token is not modified */
1574 if (memcmp(khdr
, plain_out
.data
+ plain_out
.len
- sizeof(*khdr
),
1576 CERROR("decrypted krb5 header mismatch\n");
1580 /* verify checksum, compose clear text as layout:
1581 * ------------------------------------------------------
1582 * | confounder | gss header | clear msgs | krb5 header |
1583 * ------------------------------------------------------
1585 hash_objs
[0].len
= ke
->ke_conf_size
;
1586 hash_objs
[0].data
= plain_out
.data
;
1587 hash_objs
[1].len
= gsshdr
->len
;
1588 hash_objs
[1].data
= gsshdr
->data
;
1589 hash_objs
[2].len
= plain_out
.len
- ke
->ke_conf_size
- sizeof(*khdr
);
1590 hash_objs
[2].data
= plain_out
.data
+ ke
->ke_conf_size
;
1591 if (krb5_make_checksum(kctx
->kc_enctype
, &kctx
->kc_keyi
,
1592 khdr
, 3, hash_objs
, 0, NULL
, &cksum
))
1595 LASSERT(cksum
.len
>= ke
->ke_hash_size
);
1596 if (memcmp((char *)(khdr
+ 1) + bodysize
,
1597 cksum
.data
+ cksum
.len
- ke
->ke_hash_size
,
1598 ke
->ke_hash_size
)) {
1599 CERROR("checksum mismatch\n");
1603 msg
->len
= bodysize
- ke
->ke_conf_size
- sizeof(*khdr
);
1604 memcpy(msg
->data
, tmpbuf
+ ke
->ke_conf_size
, msg
->len
);
1606 major
= GSS_S_COMPLETE
;
1608 OBD_FREE_LARGE(tmpbuf
, bodysize
);
1609 rawobj_free(&cksum
);
1614 __u32
gss_unwrap_bulk_kerberos(struct gss_ctx
*gctx
,
1615 struct ptlrpc_bulk_desc
*desc
,
1616 rawobj_t
*token
, int adj_nob
)
1618 struct krb5_ctx
*kctx
= gctx
->internal_ctx_id
;
1619 struct krb5_enctype
*ke
= &enctypes
[kctx
->kc_enctype
];
1620 struct krb5_header
*khdr
;
1622 rawobj_t cksum
= RAWOBJ_EMPTY
;
1623 rawobj_t cipher
, plain
;
1624 rawobj_t data_desc
[1];
1630 if (token
->len
< sizeof(*khdr
)) {
1631 CERROR("short signature: %u\n", token
->len
);
1632 return GSS_S_DEFECTIVE_TOKEN
;
1635 khdr
= (struct krb5_header
*) token
->data
;
1637 major
= verify_krb5_header(kctx
, khdr
, 1);
1638 if (major
!= GSS_S_COMPLETE
) {
1639 CERROR("bad krb5 header\n");
1644 if (kctx
->kc_enctype
== ENCTYPE_ARCFOUR_HMAC
) {
1645 LASSERT(kctx
->kc_keye
.kb_tfm
== NULL
);
1649 LASSERT(kctx
->kc_keye
.kb_tfm
);
1650 blocksize
= ll_crypto_blkcipher_blocksize(kctx
->kc_keye
.kb_tfm
);
1652 LASSERT(sizeof(*khdr
) >= blocksize
&& sizeof(*khdr
) % blocksize
== 0);
1655 * token format is expected as:
1656 * -----------------------------------------------
1657 * | krb5 header | head/tail cipher text | cksum |
1658 * -----------------------------------------------
1660 if (token
->len
< sizeof(*khdr
) + blocksize
+ sizeof(*khdr
) +
1662 CERROR("short token size: %u\n", token
->len
);
1663 return GSS_S_DEFECTIVE_TOKEN
;
1666 cipher
.data
= (__u8
*) (khdr
+ 1);
1667 cipher
.len
= blocksize
+ sizeof(*khdr
);
1668 plain
.data
= cipher
.data
;
1669 plain
.len
= cipher
.len
;
1671 rc
= krb5_decrypt_bulk(kctx
->kc_keye
.kb_tfm
, khdr
,
1672 desc
, &cipher
, &plain
, adj_nob
);
1674 return GSS_S_DEFECTIVE_TOKEN
;
1677 * verify checksum, compose clear text as layout:
1678 * ------------------------------------------
1679 * | confounder | clear pages | krb5 header |
1680 * ------------------------------------------
1682 data_desc
[0].data
= plain
.data
;
1683 data_desc
[0].len
= blocksize
;
1685 if (krb5_make_checksum(kctx
->kc_enctype
, &kctx
->kc_keyi
,
1687 desc
->bd_iov_count
, desc
->bd_iov
,
1689 return GSS_S_FAILURE
;
1690 LASSERT(cksum
.len
>= ke
->ke_hash_size
);
1692 if (memcmp(plain
.data
+ blocksize
+ sizeof(*khdr
),
1693 cksum
.data
+ cksum
.len
- ke
->ke_hash_size
,
1694 ke
->ke_hash_size
)) {
1695 CERROR("checksum mismatch\n");
1696 rawobj_free(&cksum
);
1697 return GSS_S_BAD_SIG
;
1700 rawobj_free(&cksum
);
1701 return GSS_S_COMPLETE
;
1704 int gss_display_kerberos(struct gss_ctx
*ctx
,
1708 struct krb5_ctx
*kctx
= ctx
->internal_ctx_id
;
1711 written
= snprintf(buf
, bufsize
, "krb5 (%s)",
1712 enctype2str(kctx
->kc_enctype
));
1716 static struct gss_api_ops gss_kerberos_ops
= {
1717 .gss_import_sec_context
= gss_import_sec_context_kerberos
,
1718 .gss_copy_reverse_context
= gss_copy_reverse_context_kerberos
,
1719 .gss_inquire_context
= gss_inquire_context_kerberos
,
1720 .gss_get_mic
= gss_get_mic_kerberos
,
1721 .gss_verify_mic
= gss_verify_mic_kerberos
,
1722 .gss_wrap
= gss_wrap_kerberos
,
1723 .gss_unwrap
= gss_unwrap_kerberos
,
1724 .gss_prep_bulk
= gss_prep_bulk_kerberos
,
1725 .gss_wrap_bulk
= gss_wrap_bulk_kerberos
,
1726 .gss_unwrap_bulk
= gss_unwrap_bulk_kerberos
,
1727 .gss_delete_sec_context
= gss_delete_sec_context_kerberos
,
1728 .gss_display
= gss_display_kerberos
,
1731 static struct subflavor_desc gss_kerberos_sfs
[] = {
1733 .sf_subflavor
= SPTLRPC_SUBFLVR_KRB5N
,
1735 .sf_service
= SPTLRPC_SVC_NULL
,
1739 .sf_subflavor
= SPTLRPC_SUBFLVR_KRB5A
,
1741 .sf_service
= SPTLRPC_SVC_AUTH
,
1745 .sf_subflavor
= SPTLRPC_SUBFLVR_KRB5I
,
1747 .sf_service
= SPTLRPC_SVC_INTG
,
1751 .sf_subflavor
= SPTLRPC_SUBFLVR_KRB5P
,
1753 .sf_service
= SPTLRPC_SVC_PRIV
,
1759 * currently we leave module owner NULL
1761 static struct gss_api_mech gss_kerberos_mech
= {
1762 .gm_owner
= NULL
, /*THIS_MODULE, */
1764 .gm_oid
= (rawobj_t
)
1765 {9, "\052\206\110\206\367\022\001\002\002"},
1766 .gm_ops
= &gss_kerberos_ops
,
1768 .gm_sfs
= gss_kerberos_sfs
,
1771 int __init
init_kerberos_module(void)
1775 spin_lock_init(&krb5_seq_lock
);
1777 status
= lgss_mech_register(&gss_kerberos_mech
);
1779 CERROR("Failed to register kerberos gss mechanism!\n");
1783 void __exit
cleanup_kerberos_module(void)
1785 lgss_mech_unregister(&gss_kerberos_mech
);