| /* |
| * Modifications for Lustre |
| * |
| * Copyright (c) 2007, 2010, Oracle and/or its affiliates. All rights reserved. |
| * |
| * Copyright (c) 2011, 2012, Intel Corporation. |
| * |
| * Author: Eric Mei <ericm@clusterfs.com> |
| */ |
| |
| /* |
| * linux/net/sunrpc/gss_krb5_mech.c |
| * linux/net/sunrpc/gss_krb5_crypto.c |
| * linux/net/sunrpc/gss_krb5_seal.c |
| * linux/net/sunrpc/gss_krb5_seqnum.c |
| * linux/net/sunrpc/gss_krb5_unseal.c |
| * |
| * Copyright (c) 2001 The Regents of the University of Michigan. |
| * All rights reserved. |
| * |
| * Andy Adamson <andros@umich.edu> |
| * J. Bruce Fields <bfields@umich.edu> |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions |
| * are met: |
| * |
| * 1. Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * 2. Redistributions in binary form must reproduce the above copyright |
| * notice, this list of conditions and the following disclaimer in the |
| * documentation and/or other materials provided with the distribution. |
| * 3. Neither the name of the University nor the names of its |
| * contributors may be used to endorse or promote products derived |
| * from this software without specific prior written permission. |
| * |
| * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED |
| * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF |
| * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE |
| * DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE |
| * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR |
| * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF |
| * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR |
| * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF |
| * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING |
| * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS |
| * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| * |
| */ |
| |
| #define DEBUG_SUBSYSTEM S_SEC |
| #include <linux/init.h> |
| #include <linux/module.h> |
| #include <linux/slab.h> |
| #include <linux/crypto.h> |
| #include <linux/mutex.h> |
| |
| #include <obd.h> |
| #include <obd_class.h> |
| #include <obd_support.h> |
| #include <lustre/lustre_idl.h> |
| #include <lustre_net.h> |
| #include <lustre_import.h> |
| #include <lustre_sec.h> |
| |
| #include "gss_err.h" |
| #include "gss_internal.h" |
| #include "gss_api.h" |
| #include "gss_asn1.h" |
| #include "gss_krb5.h" |
| |
| static spinlock_t krb5_seq_lock; |
| |
| struct krb5_enctype { |
| char *ke_dispname; |
| char *ke_enc_name; /* linux tfm name */ |
| char *ke_hash_name; /* linux tfm name */ |
| int ke_enc_mode; /* linux tfm mode */ |
| int ke_hash_size; /* checksum size */ |
| int ke_conf_size; /* confounder size */ |
| unsigned int ke_hash_hmac:1; /* is hmac? */ |
| }; |
| |
| /* |
| * NOTE: for aes128-cts and aes256-cts, MIT implementation use CTS encryption. |
| * but currently we simply CBC with padding, because linux doesn't support CTS |
| * yet. this need to be fixed in the future. |
| */ |
| static struct krb5_enctype enctypes[] = { |
| [ENCTYPE_DES_CBC_RAW] = { /* des-cbc-md5 */ |
| "des-cbc-md5", |
| "cbc(des)", |
| "md5", |
| 0, |
| 16, |
| 8, |
| 0, |
| }, |
| [ENCTYPE_DES3_CBC_RAW] = { /* des3-hmac-sha1 */ |
| "des3-hmac-sha1", |
| "cbc(des3_ede)", |
| "hmac(sha1)", |
| 0, |
| 20, |
| 8, |
| 1, |
| }, |
| [ENCTYPE_AES128_CTS_HMAC_SHA1_96] = { /* aes128-cts */ |
| "aes128-cts-hmac-sha1-96", |
| "cbc(aes)", |
| "hmac(sha1)", |
| 0, |
| 12, |
| 16, |
| 1, |
| }, |
| [ENCTYPE_AES256_CTS_HMAC_SHA1_96] = { /* aes256-cts */ |
| "aes256-cts-hmac-sha1-96", |
| "cbc(aes)", |
| "hmac(sha1)", |
| 0, |
| 12, |
| 16, |
| 1, |
| }, |
| [ENCTYPE_ARCFOUR_HMAC] = { /* arcfour-hmac-md5 */ |
| "arcfour-hmac-md5", |
| "ecb(arc4)", |
| "hmac(md5)", |
| 0, |
| 16, |
| 8, |
| 1, |
| }, |
| }; |
| |
| #define MAX_ENCTYPES sizeof(enctypes)/sizeof(struct krb5_enctype) |
| |
| static const char * enctype2str(__u32 enctype) |
| { |
| if (enctype < MAX_ENCTYPES && enctypes[enctype].ke_dispname) |
| return enctypes[enctype].ke_dispname; |
| |
| return "unknown"; |
| } |
| |
| static |
| int keyblock_init(struct krb5_keyblock *kb, char *alg_name, int alg_mode) |
| { |
| kb->kb_tfm = ll_crypto_alloc_blkcipher(alg_name, alg_mode, 0); |
| if (IS_ERR(kb->kb_tfm)) { |
| CERROR("failed to alloc tfm: %s, mode %d\n", |
| alg_name, alg_mode); |
| return -1; |
| } |
| |
| if (ll_crypto_blkcipher_setkey(kb->kb_tfm, kb->kb_key.data, kb->kb_key.len)) { |
| CERROR("failed to set %s key, len %d\n", |
| alg_name, kb->kb_key.len); |
| return -1; |
| } |
| |
| return 0; |
| } |
| |
| static |
| int krb5_init_keys(struct krb5_ctx *kctx) |
| { |
| struct krb5_enctype *ke; |
| |
| if (kctx->kc_enctype >= MAX_ENCTYPES || |
| enctypes[kctx->kc_enctype].ke_hash_size == 0) { |
| CERROR("unsupported enctype %x\n", kctx->kc_enctype); |
| return -1; |
| } |
| |
| ke = &enctypes[kctx->kc_enctype]; |
| |
| /* tfm arc4 is stateful, user should alloc-use-free by his own */ |
| if (kctx->kc_enctype != ENCTYPE_ARCFOUR_HMAC && |
| keyblock_init(&kctx->kc_keye, ke->ke_enc_name, ke->ke_enc_mode)) |
| return -1; |
| |
| /* tfm hmac is stateful, user should alloc-use-free by his own */ |
| if (ke->ke_hash_hmac == 0 && |
| keyblock_init(&kctx->kc_keyi, ke->ke_enc_name, ke->ke_enc_mode)) |
| return -1; |
| if (ke->ke_hash_hmac == 0 && |
| keyblock_init(&kctx->kc_keyc, ke->ke_enc_name, ke->ke_enc_mode)) |
| return -1; |
| |
| return 0; |
| } |
| |
| static |
| void keyblock_free(struct krb5_keyblock *kb) |
| { |
| rawobj_free(&kb->kb_key); |
| if (kb->kb_tfm) |
| ll_crypto_free_blkcipher(kb->kb_tfm); |
| } |
| |
| static |
| int keyblock_dup(struct krb5_keyblock *new, struct krb5_keyblock *kb) |
| { |
| return rawobj_dup(&new->kb_key, &kb->kb_key); |
| } |
| |
| static |
| int get_bytes(char **ptr, const char *end, void *res, int len) |
| { |
| char *p, *q; |
| p = *ptr; |
| q = p + len; |
| if (q > end || q < p) |
| return -1; |
| memcpy(res, p, len); |
| *ptr = q; |
| return 0; |
| } |
| |
| static |
| int get_rawobj(char **ptr, const char *end, rawobj_t *res) |
| { |
| char *p, *q; |
| __u32 len; |
| |
| p = *ptr; |
| if (get_bytes(&p, end, &len, sizeof(len))) |
| return -1; |
| |
| q = p + len; |
| if (q > end || q < p) |
| return -1; |
| |
| OBD_ALLOC_LARGE(res->data, len); |
| if (!res->data) |
| return -1; |
| |
| res->len = len; |
| memcpy(res->data, p, len); |
| *ptr = q; |
| return 0; |
| } |
| |
| static |
| int get_keyblock(char **ptr, const char *end, |
| struct krb5_keyblock *kb, __u32 keysize) |
| { |
| char *buf; |
| |
| OBD_ALLOC_LARGE(buf, keysize); |
| if (buf == NULL) |
| return -1; |
| |
| if (get_bytes(ptr, end, buf, keysize)) { |
| OBD_FREE_LARGE(buf, keysize); |
| return -1; |
| } |
| |
| kb->kb_key.len = keysize; |
| kb->kb_key.data = buf; |
| return 0; |
| } |
| |
| static |
| void delete_context_kerberos(struct krb5_ctx *kctx) |
| { |
| rawobj_free(&kctx->kc_mech_used); |
| |
| keyblock_free(&kctx->kc_keye); |
| keyblock_free(&kctx->kc_keyi); |
| keyblock_free(&kctx->kc_keyc); |
| } |
| |
| static |
| __u32 import_context_rfc1964(struct krb5_ctx *kctx, char *p, char *end) |
| { |
| unsigned int tmp_uint, keysize; |
| |
| /* seed_init flag */ |
| if (get_bytes(&p, end, &tmp_uint, sizeof(tmp_uint))) |
| goto out_err; |
| kctx->kc_seed_init = (tmp_uint != 0); |
| |
| /* seed */ |
| if (get_bytes(&p, end, kctx->kc_seed, sizeof(kctx->kc_seed))) |
| goto out_err; |
| |
| /* sign/seal algorithm, not really used now */ |
| if (get_bytes(&p, end, &tmp_uint, sizeof(tmp_uint)) || |
| get_bytes(&p, end, &tmp_uint, sizeof(tmp_uint))) |
| goto out_err; |
| |
| /* end time */ |
| if (get_bytes(&p, end, &kctx->kc_endtime, sizeof(kctx->kc_endtime))) |
| goto out_err; |
| |
| /* seq send */ |
| if (get_bytes(&p, end, &tmp_uint, sizeof(tmp_uint))) |
| goto out_err; |
| kctx->kc_seq_send = tmp_uint; |
| |
| /* mech oid */ |
| if (get_rawobj(&p, end, &kctx->kc_mech_used)) |
| goto out_err; |
| |
| /* old style enc/seq keys in format: |
| * - enctype (u32) |
| * - keysize (u32) |
| * - keydata |
| * we decompose them to fit into the new context |
| */ |
| |
| /* enc key */ |
| if (get_bytes(&p, end, &kctx->kc_enctype, sizeof(kctx->kc_enctype))) |
| goto out_err; |
| |
| if (get_bytes(&p, end, &keysize, sizeof(keysize))) |
| goto out_err; |
| |
| if (get_keyblock(&p, end, &kctx->kc_keye, keysize)) |
| goto out_err; |
| |
| /* seq key */ |
| if (get_bytes(&p, end, &tmp_uint, sizeof(tmp_uint)) || |
| tmp_uint != kctx->kc_enctype) |
| goto out_err; |
| |
| if (get_bytes(&p, end, &tmp_uint, sizeof(tmp_uint)) || |
| tmp_uint != keysize) |
| goto out_err; |
| |
| if (get_keyblock(&p, end, &kctx->kc_keyc, keysize)) |
| goto out_err; |
| |
| /* old style fallback */ |
| if (keyblock_dup(&kctx->kc_keyi, &kctx->kc_keyc)) |
| goto out_err; |
| |
| if (p != end) |
| goto out_err; |
| |
| CDEBUG(D_SEC, "succesfully imported rfc1964 context\n"); |
| return 0; |
| out_err: |
| return GSS_S_FAILURE; |
| } |
| |
| /* Flags for version 2 context flags */ |
| #define KRB5_CTX_FLAG_INITIATOR 0x00000001 |
| #define KRB5_CTX_FLAG_CFX 0x00000002 |
| #define KRB5_CTX_FLAG_ACCEPTOR_SUBKEY 0x00000004 |
| |
| static |
| __u32 import_context_rfc4121(struct krb5_ctx *kctx, char *p, char *end) |
| { |
| unsigned int tmp_uint, keysize; |
| |
| /* end time */ |
| if (get_bytes(&p, end, &kctx->kc_endtime, sizeof(kctx->kc_endtime))) |
| goto out_err; |
| |
| /* flags */ |
| if (get_bytes(&p, end, &tmp_uint, sizeof(tmp_uint))) |
| goto out_err; |
| |
| if (tmp_uint & KRB5_CTX_FLAG_INITIATOR) |
| kctx->kc_initiate = 1; |
| if (tmp_uint & KRB5_CTX_FLAG_CFX) |
| kctx->kc_cfx = 1; |
| if (tmp_uint & KRB5_CTX_FLAG_ACCEPTOR_SUBKEY) |
| kctx->kc_have_acceptor_subkey = 1; |
| |
| /* seq send */ |
| if (get_bytes(&p, end, &kctx->kc_seq_send, sizeof(kctx->kc_seq_send))) |
| goto out_err; |
| |
| /* enctype */ |
| if (get_bytes(&p, end, &kctx->kc_enctype, sizeof(kctx->kc_enctype))) |
| goto out_err; |
| |
| /* size of each key */ |
| if (get_bytes(&p, end, &keysize, sizeof(keysize))) |
| goto out_err; |
| |
| /* number of keys - should always be 3 */ |
| if (get_bytes(&p, end, &tmp_uint, sizeof(tmp_uint))) |
| goto out_err; |
| |
| if (tmp_uint != 3) { |
| CERROR("Invalid number of keys: %u\n", tmp_uint); |
| goto out_err; |
| } |
| |
| /* ke */ |
| if (get_keyblock(&p, end, &kctx->kc_keye, keysize)) |
| goto out_err; |
| /* ki */ |
| if (get_keyblock(&p, end, &kctx->kc_keyi, keysize)) |
| goto out_err; |
| /* ki */ |
| if (get_keyblock(&p, end, &kctx->kc_keyc, keysize)) |
| goto out_err; |
| |
| CDEBUG(D_SEC, "succesfully imported v2 context\n"); |
| return 0; |
| out_err: |
| return GSS_S_FAILURE; |
| } |
| |
| /* |
| * The whole purpose here is trying to keep user level gss context parsing |
| * from nfs-utils unchanged as possible as we can, they are not quite mature |
| * yet, and many stuff still not clear, like heimdal etc. |
| */ |
| static |
| __u32 gss_import_sec_context_kerberos(rawobj_t *inbuf, |
| struct gss_ctx *gctx) |
| { |
| struct krb5_ctx *kctx; |
| char *p = (char *) inbuf->data; |
| char *end = (char *) (inbuf->data + inbuf->len); |
| unsigned int tmp_uint, rc; |
| |
| if (get_bytes(&p, end, &tmp_uint, sizeof(tmp_uint))) { |
| CERROR("Fail to read version\n"); |
| return GSS_S_FAILURE; |
| } |
| |
| /* only support 0, 1 for the moment */ |
| if (tmp_uint > 2) { |
| CERROR("Invalid version %u\n", tmp_uint); |
| return GSS_S_FAILURE; |
| } |
| |
| OBD_ALLOC_PTR(kctx); |
| if (!kctx) |
| return GSS_S_FAILURE; |
| |
| if (tmp_uint == 0 || tmp_uint == 1) { |
| kctx->kc_initiate = tmp_uint; |
| rc = import_context_rfc1964(kctx, p, end); |
| } else { |
| rc = import_context_rfc4121(kctx, p, end); |
| } |
| |
| if (rc == 0) |
| rc = krb5_init_keys(kctx); |
| |
| if (rc) { |
| delete_context_kerberos(kctx); |
| OBD_FREE_PTR(kctx); |
| |
| return GSS_S_FAILURE; |
| } |
| |
| gctx->internal_ctx_id = kctx; |
| return GSS_S_COMPLETE; |
| } |
| |
| static |
| __u32 gss_copy_reverse_context_kerberos(struct gss_ctx *gctx, |
| struct gss_ctx *gctx_new) |
| { |
| struct krb5_ctx *kctx = gctx->internal_ctx_id; |
| struct krb5_ctx *knew; |
| |
| OBD_ALLOC_PTR(knew); |
| if (!knew) |
| return GSS_S_FAILURE; |
| |
| knew->kc_initiate = kctx->kc_initiate ? 0 : 1; |
| knew->kc_cfx = kctx->kc_cfx; |
| knew->kc_seed_init = kctx->kc_seed_init; |
| knew->kc_have_acceptor_subkey = kctx->kc_have_acceptor_subkey; |
| knew->kc_endtime = kctx->kc_endtime; |
| |
| memcpy(knew->kc_seed, kctx->kc_seed, sizeof(kctx->kc_seed)); |
| knew->kc_seq_send = kctx->kc_seq_recv; |
| knew->kc_seq_recv = kctx->kc_seq_send; |
| knew->kc_enctype = kctx->kc_enctype; |
| |
| if (rawobj_dup(&knew->kc_mech_used, &kctx->kc_mech_used)) |
| goto out_err; |
| |
| if (keyblock_dup(&knew->kc_keye, &kctx->kc_keye)) |
| goto out_err; |
| if (keyblock_dup(&knew->kc_keyi, &kctx->kc_keyi)) |
| goto out_err; |
| if (keyblock_dup(&knew->kc_keyc, &kctx->kc_keyc)) |
| goto out_err; |
| if (krb5_init_keys(knew)) |
| goto out_err; |
| |
| gctx_new->internal_ctx_id = knew; |
| CDEBUG(D_SEC, "succesfully copied reverse context\n"); |
| return GSS_S_COMPLETE; |
| |
| out_err: |
| delete_context_kerberos(knew); |
| OBD_FREE_PTR(knew); |
| return GSS_S_FAILURE; |
| } |
| |
| static |
| __u32 gss_inquire_context_kerberos(struct gss_ctx *gctx, |
| unsigned long *endtime) |
| { |
| struct krb5_ctx *kctx = gctx->internal_ctx_id; |
| |
| *endtime = (unsigned long) ((__u32) kctx->kc_endtime); |
| return GSS_S_COMPLETE; |
| } |
| |
| static |
| void gss_delete_sec_context_kerberos(void *internal_ctx) |
| { |
| struct krb5_ctx *kctx = internal_ctx; |
| |
| delete_context_kerberos(kctx); |
| OBD_FREE_PTR(kctx); |
| } |
| |
| static |
| void buf_to_sg(struct scatterlist *sg, void *ptr, int len) |
| { |
| sg_set_buf(sg, ptr, len); |
| } |
| |
| static |
| __u32 krb5_encrypt(struct ll_crypto_cipher *tfm, |
| int decrypt, |
| void * iv, |
| void * in, |
| void * out, |
| int length) |
| { |
| struct blkcipher_desc desc; |
| struct scatterlist sg; |
| __u8 local_iv[16] = {0}; |
| __u32 ret = -EINVAL; |
| |
| LASSERT(tfm); |
| desc.tfm = tfm; |
| desc.info = local_iv; |
| desc.flags= 0; |
| |
| if (length % ll_crypto_blkcipher_blocksize(tfm) != 0) { |
| CERROR("output length %d mismatch blocksize %d\n", |
| length, ll_crypto_blkcipher_blocksize(tfm)); |
| goto out; |
| } |
| |
| if (ll_crypto_blkcipher_ivsize(tfm) > 16) { |
| CERROR("iv size too large %d\n", ll_crypto_blkcipher_ivsize(tfm)); |
| goto out; |
| } |
| |
| if (iv) |
| memcpy(local_iv, iv, ll_crypto_blkcipher_ivsize(tfm)); |
| |
| memcpy(out, in, length); |
| buf_to_sg(&sg, out, length); |
| |
| if (decrypt) |
| ret = ll_crypto_blkcipher_decrypt_iv(&desc, &sg, &sg, length); |
| else |
| ret = ll_crypto_blkcipher_encrypt_iv(&desc, &sg, &sg, length); |
| |
| out: |
| return(ret); |
| } |
| |
| |
| static inline |
| int krb5_digest_hmac(struct ll_crypto_hash *tfm, |
| rawobj_t *key, |
| struct krb5_header *khdr, |
| int msgcnt, rawobj_t *msgs, |
| int iovcnt, lnet_kiov_t *iovs, |
| rawobj_t *cksum) |
| { |
| struct hash_desc desc; |
| struct scatterlist sg[1]; |
| int i; |
| |
| ll_crypto_hash_setkey(tfm, key->data, key->len); |
| desc.tfm = tfm; |
| desc.flags= 0; |
| |
| ll_crypto_hash_init(&desc); |
| |
| for (i = 0; i < msgcnt; i++) { |
| if (msgs[i].len == 0) |
| continue; |
| buf_to_sg(sg, (char *) msgs[i].data, msgs[i].len); |
| ll_crypto_hash_update(&desc, sg, msgs[i].len); |
| } |
| |
| for (i = 0; i < iovcnt; i++) { |
| if (iovs[i].kiov_len == 0) |
| continue; |
| |
| sg_set_page(&sg[0], iovs[i].kiov_page, iovs[i].kiov_len, |
| iovs[i].kiov_offset); |
| ll_crypto_hash_update(&desc, sg, iovs[i].kiov_len); |
| } |
| |
| if (khdr) { |
| buf_to_sg(sg, (char *) khdr, sizeof(*khdr)); |
| ll_crypto_hash_update(&desc, sg, sizeof(*khdr)); |
| } |
| |
| return ll_crypto_hash_final(&desc, cksum->data); |
| } |
| |
| |
| static inline |
| int krb5_digest_norm(struct ll_crypto_hash *tfm, |
| struct krb5_keyblock *kb, |
| struct krb5_header *khdr, |
| int msgcnt, rawobj_t *msgs, |
| int iovcnt, lnet_kiov_t *iovs, |
| rawobj_t *cksum) |
| { |
| struct hash_desc desc; |
| struct scatterlist sg[1]; |
| int i; |
| |
| LASSERT(kb->kb_tfm); |
| desc.tfm = tfm; |
| desc.flags= 0; |
| |
| ll_crypto_hash_init(&desc); |
| |
| for (i = 0; i < msgcnt; i++) { |
| if (msgs[i].len == 0) |
| continue; |
| buf_to_sg(sg, (char *) msgs[i].data, msgs[i].len); |
| ll_crypto_hash_update(&desc, sg, msgs[i].len); |
| } |
| |
| for (i = 0; i < iovcnt; i++) { |
| if (iovs[i].kiov_len == 0) |
| continue; |
| |
| sg_set_page(&sg[0], iovs[i].kiov_page, iovs[i].kiov_len, |
| iovs[i].kiov_offset); |
| ll_crypto_hash_update(&desc, sg, iovs[i].kiov_len); |
| } |
| |
| if (khdr) { |
| buf_to_sg(sg, (char *) khdr, sizeof(*khdr)); |
| ll_crypto_hash_update(&desc, sg, sizeof(*khdr)); |
| } |
| |
| ll_crypto_hash_final(&desc, cksum->data); |
| |
| return krb5_encrypt(kb->kb_tfm, 0, NULL, cksum->data, |
| cksum->data, cksum->len); |
| } |
| |
| /* |
| * compute (keyed/keyless) checksum against the plain text which appended |
| * with krb5 wire token header. |
| */ |
| static |
| __s32 krb5_make_checksum(__u32 enctype, |
| struct krb5_keyblock *kb, |
| struct krb5_header *khdr, |
| int msgcnt, rawobj_t *msgs, |
| int iovcnt, lnet_kiov_t *iovs, |
| rawobj_t *cksum) |
| { |
| struct krb5_enctype *ke = &enctypes[enctype]; |
| struct ll_crypto_hash *tfm; |
| __u32 code = GSS_S_FAILURE; |
| int rc; |
| |
| if (!(tfm = ll_crypto_alloc_hash(ke->ke_hash_name, 0, 0))) { |
| CERROR("failed to alloc TFM: %s\n", ke->ke_hash_name); |
| return GSS_S_FAILURE; |
| } |
| |
| cksum->len = ll_crypto_hash_digestsize(tfm); |
| OBD_ALLOC_LARGE(cksum->data, cksum->len); |
| if (!cksum->data) { |
| cksum->len = 0; |
| goto out_tfm; |
| } |
| |
| if (ke->ke_hash_hmac) |
| rc = krb5_digest_hmac(tfm, &kb->kb_key, |
| khdr, msgcnt, msgs, iovcnt, iovs, cksum); |
| else |
| rc = krb5_digest_norm(tfm, kb, |
| khdr, msgcnt, msgs, iovcnt, iovs, cksum); |
| |
| if (rc == 0) |
| code = GSS_S_COMPLETE; |
| out_tfm: |
| ll_crypto_free_hash(tfm); |
| return code; |
| } |
| |
| static void fill_krb5_header(struct krb5_ctx *kctx, |
| struct krb5_header *khdr, |
| int privacy) |
| { |
| unsigned char acceptor_flag; |
| |
| acceptor_flag = kctx->kc_initiate ? 0 : FLAG_SENDER_IS_ACCEPTOR; |
| |
| if (privacy) { |
| khdr->kh_tok_id = cpu_to_be16(KG_TOK_WRAP_MSG); |
| khdr->kh_flags = acceptor_flag | FLAG_WRAP_CONFIDENTIAL; |
| khdr->kh_ec = cpu_to_be16(0); |
| khdr->kh_rrc = cpu_to_be16(0); |
| } else { |
| khdr->kh_tok_id = cpu_to_be16(KG_TOK_MIC_MSG); |
| khdr->kh_flags = acceptor_flag; |
| khdr->kh_ec = cpu_to_be16(0xffff); |
| khdr->kh_rrc = cpu_to_be16(0xffff); |
| } |
| |
| khdr->kh_filler = 0xff; |
| spin_lock(&krb5_seq_lock); |
| khdr->kh_seq = cpu_to_be64(kctx->kc_seq_send++); |
| spin_unlock(&krb5_seq_lock); |
| } |
| |
| static __u32 verify_krb5_header(struct krb5_ctx *kctx, |
| struct krb5_header *khdr, |
| int privacy) |
| { |
| unsigned char acceptor_flag; |
| __u16 tok_id, ec_rrc; |
| |
| acceptor_flag = kctx->kc_initiate ? FLAG_SENDER_IS_ACCEPTOR : 0; |
| |
| if (privacy) { |
| tok_id = KG_TOK_WRAP_MSG; |
| ec_rrc = 0x0; |
| } else { |
| tok_id = KG_TOK_MIC_MSG; |
| ec_rrc = 0xffff; |
| } |
| |
| /* sanity checks */ |
| if (be16_to_cpu(khdr->kh_tok_id) != tok_id) { |
| CERROR("bad token id\n"); |
| return GSS_S_DEFECTIVE_TOKEN; |
| } |
| if ((khdr->kh_flags & FLAG_SENDER_IS_ACCEPTOR) != acceptor_flag) { |
| CERROR("bad direction flag\n"); |
| return GSS_S_BAD_SIG; |
| } |
| if (privacy && (khdr->kh_flags & FLAG_WRAP_CONFIDENTIAL) == 0) { |
| CERROR("missing confidential flag\n"); |
| return GSS_S_BAD_SIG; |
| } |
| if (khdr->kh_filler != 0xff) { |
| CERROR("bad filler\n"); |
| return GSS_S_DEFECTIVE_TOKEN; |
| } |
| if (be16_to_cpu(khdr->kh_ec) != ec_rrc || |
| be16_to_cpu(khdr->kh_rrc) != ec_rrc) { |
| CERROR("bad EC or RRC\n"); |
| return GSS_S_DEFECTIVE_TOKEN; |
| } |
| return GSS_S_COMPLETE; |
| } |
| |
| static |
| __u32 gss_get_mic_kerberos(struct gss_ctx *gctx, |
| int msgcnt, |
| rawobj_t *msgs, |
| int iovcnt, |
| lnet_kiov_t *iovs, |
| rawobj_t *token) |
| { |
| struct krb5_ctx *kctx = gctx->internal_ctx_id; |
| struct krb5_enctype *ke = &enctypes[kctx->kc_enctype]; |
| struct krb5_header *khdr; |
| rawobj_t cksum = RAWOBJ_EMPTY; |
| |
| /* fill krb5 header */ |
| LASSERT(token->len >= sizeof(*khdr)); |
| khdr = (struct krb5_header *) token->data; |
| fill_krb5_header(kctx, khdr, 0); |
| |
| /* checksum */ |
| if (krb5_make_checksum(kctx->kc_enctype, &kctx->kc_keyc, |
| khdr, msgcnt, msgs, iovcnt, iovs, &cksum)) |
| return GSS_S_FAILURE; |
| |
| LASSERT(cksum.len >= ke->ke_hash_size); |
| LASSERT(token->len >= sizeof(*khdr) + ke->ke_hash_size); |
| memcpy(khdr + 1, cksum.data + cksum.len - ke->ke_hash_size, |
| ke->ke_hash_size); |
| |
| token->len = sizeof(*khdr) + ke->ke_hash_size; |
| rawobj_free(&cksum); |
| return GSS_S_COMPLETE; |
| } |
| |
| static |
| __u32 gss_verify_mic_kerberos(struct gss_ctx *gctx, |
| int msgcnt, |
| rawobj_t *msgs, |
| int iovcnt, |
| lnet_kiov_t *iovs, |
| rawobj_t *token) |
| { |
| struct krb5_ctx *kctx = gctx->internal_ctx_id; |
| struct krb5_enctype *ke = &enctypes[kctx->kc_enctype]; |
| struct krb5_header *khdr; |
| rawobj_t cksum = RAWOBJ_EMPTY; |
| __u32 major; |
| |
| if (token->len < sizeof(*khdr)) { |
| CERROR("short signature: %u\n", token->len); |
| return GSS_S_DEFECTIVE_TOKEN; |
| } |
| |
| khdr = (struct krb5_header *) token->data; |
| |
| major = verify_krb5_header(kctx, khdr, 0); |
| if (major != GSS_S_COMPLETE) { |
| CERROR("bad krb5 header\n"); |
| return major; |
| } |
| |
| if (token->len < sizeof(*khdr) + ke->ke_hash_size) { |
| CERROR("short signature: %u, require %d\n", |
| token->len, (int) sizeof(*khdr) + ke->ke_hash_size); |
| return GSS_S_FAILURE; |
| } |
| |
| if (krb5_make_checksum(kctx->kc_enctype, &kctx->kc_keyc, |
| khdr, msgcnt, msgs, iovcnt, iovs, &cksum)) { |
| CERROR("failed to make checksum\n"); |
| return GSS_S_FAILURE; |
| } |
| |
| LASSERT(cksum.len >= ke->ke_hash_size); |
| if (memcmp(khdr + 1, cksum.data + cksum.len - ke->ke_hash_size, |
| ke->ke_hash_size)) { |
| CERROR("checksum mismatch\n"); |
| rawobj_free(&cksum); |
| return GSS_S_BAD_SIG; |
| } |
| |
| rawobj_free(&cksum); |
| return GSS_S_COMPLETE; |
| } |
| |
| static |
| int add_padding(rawobj_t *msg, int msg_buflen, int blocksize) |
| { |
| int padding; |
| |
| padding = (blocksize - (msg->len & (blocksize - 1))) & |
| (blocksize - 1); |
| if (!padding) |
| return 0; |
| |
| if (msg->len + padding > msg_buflen) { |
| CERROR("bufsize %u too small: datalen %u, padding %u\n", |
| msg_buflen, msg->len, padding); |
| return -EINVAL; |
| } |
| |
| memset(msg->data + msg->len, padding, padding); |
| msg->len += padding; |
| return 0; |
| } |
| |
| static |
| int krb5_encrypt_rawobjs(struct ll_crypto_cipher *tfm, |
| int mode_ecb, |
| int inobj_cnt, |
| rawobj_t *inobjs, |
| rawobj_t *outobj, |
| int enc) |
| { |
| struct blkcipher_desc desc; |
| struct scatterlist src, dst; |
| __u8 local_iv[16] = {0}, *buf; |
| __u32 datalen = 0; |
| int i, rc; |
| ENTRY; |
| |
| buf = outobj->data; |
| desc.tfm = tfm; |
| desc.info = local_iv; |
| desc.flags = 0; |
| |
| for (i = 0; i < inobj_cnt; i++) { |
| LASSERT(buf + inobjs[i].len <= outobj->data + outobj->len); |
| |
| buf_to_sg(&src, inobjs[i].data, inobjs[i].len); |
| buf_to_sg(&dst, buf, outobj->len - datalen); |
| |
| if (mode_ecb) { |
| if (enc) |
| rc = ll_crypto_blkcipher_encrypt( |
| &desc, &dst, &src, src.length); |
| else |
| rc = ll_crypto_blkcipher_decrypt( |
| &desc, &dst, &src, src.length); |
| } else { |
| if (enc) |
| rc = ll_crypto_blkcipher_encrypt_iv( |
| &desc, &dst, &src, src.length); |
| else |
| rc = ll_crypto_blkcipher_decrypt_iv( |
| &desc, &dst, &src, src.length); |
| } |
| |
| if (rc) { |
| CERROR("encrypt error %d\n", rc); |
| RETURN(rc); |
| } |
| |
| datalen += inobjs[i].len; |
| buf += inobjs[i].len; |
| } |
| |
| outobj->len = datalen; |
| RETURN(0); |
| } |
| |
| /* |
| * if adj_nob != 0, we adjust desc->bd_nob to the actual cipher text size. |
| */ |
| static |
| int krb5_encrypt_bulk(struct ll_crypto_cipher *tfm, |
| struct krb5_header *khdr, |
| char *confounder, |
| struct ptlrpc_bulk_desc *desc, |
| rawobj_t *cipher, |
| int adj_nob) |
| { |
| struct blkcipher_desc ciph_desc; |
| __u8 local_iv[16] = {0}; |
| struct scatterlist src, dst; |
| int blocksize, i, rc, nob = 0; |
| |
| LASSERT(desc->bd_iov_count); |
| LASSERT(desc->bd_enc_iov); |
| |
| blocksize = ll_crypto_blkcipher_blocksize(tfm); |
| LASSERT(blocksize > 1); |
| LASSERT(cipher->len == blocksize + sizeof(*khdr)); |
| |
| ciph_desc.tfm = tfm; |
| ciph_desc.info = local_iv; |
| ciph_desc.flags = 0; |
| |
| /* encrypt confounder */ |
| buf_to_sg(&src, confounder, blocksize); |
| buf_to_sg(&dst, cipher->data, blocksize); |
| |
| rc = ll_crypto_blkcipher_encrypt_iv(&ciph_desc, &dst, &src, blocksize); |
| if (rc) { |
| CERROR("error to encrypt confounder: %d\n", rc); |
| return rc; |
| } |
| |
| /* encrypt clear pages */ |
| for (i = 0; i < desc->bd_iov_count; i++) { |
| sg_set_page(&src, desc->bd_iov[i].kiov_page, |
| (desc->bd_iov[i].kiov_len + blocksize - 1) & |
| (~(blocksize - 1)), |
| desc->bd_iov[i].kiov_offset); |
| if (adj_nob) |
| nob += src.length; |
| sg_set_page(&dst, desc->bd_enc_iov[i].kiov_page, src.length, |
| src.offset); |
| |
| desc->bd_enc_iov[i].kiov_offset = dst.offset; |
| desc->bd_enc_iov[i].kiov_len = dst.length; |
| |
| rc = ll_crypto_blkcipher_encrypt_iv(&ciph_desc, &dst, &src, |
| src.length); |
| if (rc) { |
| CERROR("error to encrypt page: %d\n", rc); |
| return rc; |
| } |
| } |
| |
| /* encrypt krb5 header */ |
| buf_to_sg(&src, khdr, sizeof(*khdr)); |
| buf_to_sg(&dst, cipher->data + blocksize, sizeof(*khdr)); |
| |
| rc = ll_crypto_blkcipher_encrypt_iv(&ciph_desc, |
| &dst, &src, sizeof(*khdr)); |
| if (rc) { |
| CERROR("error to encrypt krb5 header: %d\n", rc); |
| return rc; |
| } |
| |
| if (adj_nob) |
| desc->bd_nob = nob; |
| |
| return 0; |
| } |
| |
| /* |
| * desc->bd_nob_transferred is the size of cipher text received. |
| * desc->bd_nob is the target size of plain text supposed to be. |
| * |
| * if adj_nob != 0, we adjust each page's kiov_len to the actual |
| * plain text size. |
| * - for client read: we don't know data size for each page, so |
| * bd_iov[]->kiov_len is set to PAGE_SIZE, but actual data received might |
| * be smaller, so we need to adjust it according to bd_enc_iov[]->kiov_len. |
| * this means we DO NOT support the situation that server send an odd size |
| * data in a page which is not the last one. |
| * - for server write: we knows exactly data size for each page being expected, |
| * thus kiov_len is accurate already, so we should not adjust it at all. |
| * and bd_enc_iov[]->kiov_len should be round_up(bd_iov[]->kiov_len) which |
| * should have been done by prep_bulk(). |
| */ |
| static |
| int krb5_decrypt_bulk(struct ll_crypto_cipher *tfm, |
| struct krb5_header *khdr, |
| struct ptlrpc_bulk_desc *desc, |
| rawobj_t *cipher, |
| rawobj_t *plain, |
| int adj_nob) |
| { |
| struct blkcipher_desc ciph_desc; |
| __u8 local_iv[16] = {0}; |
| struct scatterlist src, dst; |
| int ct_nob = 0, pt_nob = 0; |
| int blocksize, i, rc; |
| |
| LASSERT(desc->bd_iov_count); |
| LASSERT(desc->bd_enc_iov); |
| LASSERT(desc->bd_nob_transferred); |
| |
| blocksize = ll_crypto_blkcipher_blocksize(tfm); |
| LASSERT(blocksize > 1); |
| LASSERT(cipher->len == blocksize + sizeof(*khdr)); |
| |
| ciph_desc.tfm = tfm; |
| ciph_desc.info = local_iv; |
| ciph_desc.flags = 0; |
| |
| if (desc->bd_nob_transferred % blocksize) { |
| CERROR("odd transferred nob: %d\n", desc->bd_nob_transferred); |
| return -EPROTO; |
| } |
| |
| /* decrypt head (confounder) */ |
| buf_to_sg(&src, cipher->data, blocksize); |
| buf_to_sg(&dst, plain->data, blocksize); |
| |
| rc = ll_crypto_blkcipher_decrypt_iv(&ciph_desc, &dst, &src, blocksize); |
| if (rc) { |
| CERROR("error to decrypt confounder: %d\n", rc); |
| return rc; |
| } |
| |
| for (i = 0; i < desc->bd_iov_count && ct_nob < desc->bd_nob_transferred; |
| i++) { |
| if (desc->bd_enc_iov[i].kiov_offset % blocksize != 0 || |
| desc->bd_enc_iov[i].kiov_len % blocksize != 0) { |
| CERROR("page %d: odd offset %u len %u, blocksize %d\n", |
| i, desc->bd_enc_iov[i].kiov_offset, |
| desc->bd_enc_iov[i].kiov_len, blocksize); |
| return -EFAULT; |
| } |
| |
| if (adj_nob) { |
| if (ct_nob + desc->bd_enc_iov[i].kiov_len > |
| desc->bd_nob_transferred) |
| desc->bd_enc_iov[i].kiov_len = |
| desc->bd_nob_transferred - ct_nob; |
| |
| desc->bd_iov[i].kiov_len = desc->bd_enc_iov[i].kiov_len; |
| if (pt_nob + desc->bd_enc_iov[i].kiov_len >desc->bd_nob) |
| desc->bd_iov[i].kiov_len = desc->bd_nob -pt_nob; |
| } else { |
| /* this should be guaranteed by LNET */ |
| LASSERT(ct_nob + desc->bd_enc_iov[i].kiov_len <= |
| desc->bd_nob_transferred); |
| LASSERT(desc->bd_iov[i].kiov_len <= |
| desc->bd_enc_iov[i].kiov_len); |
| } |
| |
| if (desc->bd_enc_iov[i].kiov_len == 0) |
| continue; |
| |
| sg_set_page(&src, desc->bd_enc_iov[i].kiov_page, |
| desc->bd_enc_iov[i].kiov_len, |
| desc->bd_enc_iov[i].kiov_offset); |
| dst = src; |
| if (desc->bd_iov[i].kiov_len % blocksize == 0) |
| sg_assign_page(&dst, desc->bd_iov[i].kiov_page); |
| |
| rc = ll_crypto_blkcipher_decrypt_iv(&ciph_desc, &dst, &src, |
| src.length); |
| if (rc) { |
| CERROR("error to decrypt page: %d\n", rc); |
| return rc; |
| } |
| |
| if (desc->bd_iov[i].kiov_len % blocksize != 0) { |
| memcpy(page_address(desc->bd_iov[i].kiov_page) + |
| desc->bd_iov[i].kiov_offset, |
| page_address(desc->bd_enc_iov[i].kiov_page) + |
| desc->bd_iov[i].kiov_offset, |
| desc->bd_iov[i].kiov_len); |
| } |
| |
| ct_nob += desc->bd_enc_iov[i].kiov_len; |
| pt_nob += desc->bd_iov[i].kiov_len; |
| } |
| |
| if (unlikely(ct_nob != desc->bd_nob_transferred)) { |
| CERROR("%d cipher text transferred but only %d decrypted\n", |
| desc->bd_nob_transferred, ct_nob); |
| return -EFAULT; |
| } |
| |
| if (unlikely(!adj_nob && pt_nob != desc->bd_nob)) { |
| CERROR("%d plain text expected but only %d received\n", |
| desc->bd_nob, pt_nob); |
| return -EFAULT; |
| } |
| |
| /* if needed, clear up the rest unused iovs */ |
| if (adj_nob) |
| while (i < desc->bd_iov_count) |
| desc->bd_iov[i++].kiov_len = 0; |
| |
| /* decrypt tail (krb5 header) */ |
| buf_to_sg(&src, cipher->data + blocksize, sizeof(*khdr)); |
| buf_to_sg(&dst, cipher->data + blocksize, sizeof(*khdr)); |
| |
| rc = ll_crypto_blkcipher_decrypt_iv(&ciph_desc, |
| &dst, &src, sizeof(*khdr)); |
| if (rc) { |
| CERROR("error to decrypt tail: %d\n", rc); |
| return rc; |
| } |
| |
| if (memcmp(cipher->data + blocksize, khdr, sizeof(*khdr))) { |
| CERROR("krb5 header doesn't match\n"); |
| return -EACCES; |
| } |
| |
| return 0; |
| } |
| |
| static |
| __u32 gss_wrap_kerberos(struct gss_ctx *gctx, |
| rawobj_t *gsshdr, |
| rawobj_t *msg, |
| int msg_buflen, |
| rawobj_t *token) |
| { |
| struct krb5_ctx *kctx = gctx->internal_ctx_id; |
| struct krb5_enctype *ke = &enctypes[kctx->kc_enctype]; |
| struct krb5_header *khdr; |
| int blocksize; |
| rawobj_t cksum = RAWOBJ_EMPTY; |
| rawobj_t data_desc[3], cipher; |
| __u8 conf[GSS_MAX_CIPHER_BLOCK]; |
| int rc = 0; |
| |
| LASSERT(ke); |
| LASSERT(ke->ke_conf_size <= GSS_MAX_CIPHER_BLOCK); |
| LASSERT(kctx->kc_keye.kb_tfm == NULL || |
| ke->ke_conf_size >= |
| ll_crypto_blkcipher_blocksize(kctx->kc_keye.kb_tfm)); |
| |
| /* |
| * final token format: |
| * --------------------------------------------------- |
| * | krb5 header | cipher text | checksum (16 bytes) | |
| * --------------------------------------------------- |
| */ |
| |
| /* fill krb5 header */ |
| LASSERT(token->len >= sizeof(*khdr)); |
| khdr = (struct krb5_header *) token->data; |
| fill_krb5_header(kctx, khdr, 1); |
| |
| /* generate confounder */ |
| cfs_get_random_bytes(conf, ke->ke_conf_size); |
| |
| /* get encryption blocksize. note kc_keye might not associated with |
| * a tfm, currently only for arcfour-hmac */ |
| if (kctx->kc_enctype == ENCTYPE_ARCFOUR_HMAC) { |
| LASSERT(kctx->kc_keye.kb_tfm == NULL); |
| blocksize = 1; |
| } else { |
| LASSERT(kctx->kc_keye.kb_tfm); |
| blocksize = ll_crypto_blkcipher_blocksize(kctx->kc_keye.kb_tfm); |
| } |
| LASSERT(blocksize <= ke->ke_conf_size); |
| |
| /* padding the message */ |
| if (add_padding(msg, msg_buflen, blocksize)) |
| return GSS_S_FAILURE; |
| |
| /* |
| * clear text layout for checksum: |
| * ------------------------------------------------------ |
| * | confounder | gss header | clear msgs | krb5 header | |
| * ------------------------------------------------------ |
| */ |
| data_desc[0].data = conf; |
| data_desc[0].len = ke->ke_conf_size; |
| data_desc[1].data = gsshdr->data; |
| data_desc[1].len = gsshdr->len; |
| data_desc[2].data = msg->data; |
| data_desc[2].len = msg->len; |
| |
| /* compute checksum */ |
| if (krb5_make_checksum(kctx->kc_enctype, &kctx->kc_keyi, |
| khdr, 3, data_desc, 0, NULL, &cksum)) |
| return GSS_S_FAILURE; |
| LASSERT(cksum.len >= ke->ke_hash_size); |
| |
| /* |
| * clear text layout for encryption: |
| * ----------------------------------------- |
| * | confounder | clear msgs | krb5 header | |
| * ----------------------------------------- |
| */ |
| data_desc[0].data = conf; |
| data_desc[0].len = ke->ke_conf_size; |
| data_desc[1].data = msg->data; |
| data_desc[1].len = msg->len; |
| data_desc[2].data = (__u8 *) khdr; |
| data_desc[2].len = sizeof(*khdr); |
| |
| /* cipher text will be directly inplace */ |
| cipher.data = (__u8 *) (khdr + 1); |
| cipher.len = token->len - sizeof(*khdr); |
| LASSERT(cipher.len >= ke->ke_conf_size + msg->len + sizeof(*khdr)); |
| |
| if (kctx->kc_enctype == ENCTYPE_ARCFOUR_HMAC) { |
| rawobj_t arc4_keye; |
| struct ll_crypto_cipher *arc4_tfm; |
| |
| if (krb5_make_checksum(ENCTYPE_ARCFOUR_HMAC, &kctx->kc_keyi, |
| NULL, 1, &cksum, 0, NULL, &arc4_keye)) { |
| CERROR("failed to obtain arc4 enc key\n"); |
| GOTO(arc4_out, rc = -EACCES); |
| } |
| |
| arc4_tfm = ll_crypto_alloc_blkcipher("ecb(arc4)", 0, 0); |
| if (IS_ERR(arc4_tfm)) { |
| CERROR("failed to alloc tfm arc4 in ECB mode\n"); |
| GOTO(arc4_out_key, rc = -EACCES); |
| } |
| |
| if (ll_crypto_blkcipher_setkey(arc4_tfm, arc4_keye.data, |
| arc4_keye.len)) { |
| CERROR("failed to set arc4 key, len %d\n", |
| arc4_keye.len); |
| GOTO(arc4_out_tfm, rc = -EACCES); |
| } |
| |
| rc = krb5_encrypt_rawobjs(arc4_tfm, 1, |
| 3, data_desc, &cipher, 1); |
| arc4_out_tfm: |
| ll_crypto_free_blkcipher(arc4_tfm); |
| arc4_out_key: |
| rawobj_free(&arc4_keye); |
| arc4_out: |
| do {} while(0); /* just to avoid compile warning */ |
| } else { |
| rc = krb5_encrypt_rawobjs(kctx->kc_keye.kb_tfm, 0, |
| 3, data_desc, &cipher, 1); |
| } |
| |
| if (rc != 0) { |
| rawobj_free(&cksum); |
| return GSS_S_FAILURE; |
| } |
| |
| /* fill in checksum */ |
| LASSERT(token->len >= sizeof(*khdr) + cipher.len + ke->ke_hash_size); |
| memcpy((char *)(khdr + 1) + cipher.len, |
| cksum.data + cksum.len - ke->ke_hash_size, |
| ke->ke_hash_size); |
| rawobj_free(&cksum); |
| |
| /* final token length */ |
| token->len = sizeof(*khdr) + cipher.len + ke->ke_hash_size; |
| return GSS_S_COMPLETE; |
| } |
| |
| static |
| __u32 gss_prep_bulk_kerberos(struct gss_ctx *gctx, |
| struct ptlrpc_bulk_desc *desc) |
| { |
| struct krb5_ctx *kctx = gctx->internal_ctx_id; |
| int blocksize, i; |
| |
| LASSERT(desc->bd_iov_count); |
| LASSERT(desc->bd_enc_iov); |
| LASSERT(kctx->kc_keye.kb_tfm); |
| |
| blocksize = ll_crypto_blkcipher_blocksize(kctx->kc_keye.kb_tfm); |
| |
| for (i = 0; i < desc->bd_iov_count; i++) { |
| LASSERT(desc->bd_enc_iov[i].kiov_page); |
| /* |
| * offset should always start at page boundary of either |
| * client or server side. |
| */ |
| if (desc->bd_iov[i].kiov_offset & blocksize) { |
| CERROR("odd offset %d in page %d\n", |
| desc->bd_iov[i].kiov_offset, i); |
| return GSS_S_FAILURE; |
| } |
| |
| desc->bd_enc_iov[i].kiov_offset = desc->bd_iov[i].kiov_offset; |
| desc->bd_enc_iov[i].kiov_len = (desc->bd_iov[i].kiov_len + |
| blocksize - 1) & (~(blocksize - 1)); |
| } |
| |
| return GSS_S_COMPLETE; |
| } |
| |
| static |
| __u32 gss_wrap_bulk_kerberos(struct gss_ctx *gctx, |
| struct ptlrpc_bulk_desc *desc, |
| rawobj_t *token, int adj_nob) |
| { |
| struct krb5_ctx *kctx = gctx->internal_ctx_id; |
| struct krb5_enctype *ke = &enctypes[kctx->kc_enctype]; |
| struct krb5_header *khdr; |
| int blocksize; |
| rawobj_t cksum = RAWOBJ_EMPTY; |
| rawobj_t data_desc[1], cipher; |
| __u8 conf[GSS_MAX_CIPHER_BLOCK]; |
| int rc = 0; |
| |
| LASSERT(ke); |
| LASSERT(ke->ke_conf_size <= GSS_MAX_CIPHER_BLOCK); |
| |
| /* |
| * final token format: |
| * -------------------------------------------------- |
| * | krb5 header | head/tail cipher text | checksum | |
| * -------------------------------------------------- |
| */ |
| |
| /* fill krb5 header */ |
| LASSERT(token->len >= sizeof(*khdr)); |
| khdr = (struct krb5_header *) token->data; |
| fill_krb5_header(kctx, khdr, 1); |
| |
| /* generate confounder */ |
| cfs_get_random_bytes(conf, ke->ke_conf_size); |
| |
| /* get encryption blocksize. note kc_keye might not associated with |
| * a tfm, currently only for arcfour-hmac */ |
| if (kctx->kc_enctype == ENCTYPE_ARCFOUR_HMAC) { |
| LASSERT(kctx->kc_keye.kb_tfm == NULL); |
| blocksize = 1; |
| } else { |
| LASSERT(kctx->kc_keye.kb_tfm); |
| blocksize = ll_crypto_blkcipher_blocksize(kctx->kc_keye.kb_tfm); |
| } |
| |
| /* |
| * we assume the size of krb5_header (16 bytes) must be n * blocksize. |
| * the bulk token size would be exactly (sizeof(krb5_header) + |
| * blocksize + sizeof(krb5_header) + hashsize) |
| */ |
| LASSERT(blocksize <= ke->ke_conf_size); |
| LASSERT(sizeof(*khdr) >= blocksize && sizeof(*khdr) % blocksize == 0); |
| LASSERT(token->len >= sizeof(*khdr) + blocksize + sizeof(*khdr) + 16); |
| |
| /* |
| * clear text layout for checksum: |
| * ------------------------------------------ |
| * | confounder | clear pages | krb5 header | |
| * ------------------------------------------ |
| */ |
| data_desc[0].data = conf; |
| data_desc[0].len = ke->ke_conf_size; |
| |
| /* compute checksum */ |
| if (krb5_make_checksum(kctx->kc_enctype, &kctx->kc_keyi, |
| khdr, 1, data_desc, |
| desc->bd_iov_count, desc->bd_iov, |
| &cksum)) |
| return GSS_S_FAILURE; |
| LASSERT(cksum.len >= ke->ke_hash_size); |
| |
| /* |
| * clear text layout for encryption: |
| * ------------------------------------------ |
| * | confounder | clear pages | krb5 header | |
| * ------------------------------------------ |
| * | | | |
| * ---------- (cipher pages) | |
| * result token: | | |
| * ------------------------------------------- |
| * | krb5 header | cipher text | cipher text | |
| * ------------------------------------------- |
| */ |
| data_desc[0].data = conf; |
| data_desc[0].len = ke->ke_conf_size; |
| |
| cipher.data = (__u8 *) (khdr + 1); |
| cipher.len = blocksize + sizeof(*khdr); |
| |
| if (kctx->kc_enctype == ENCTYPE_ARCFOUR_HMAC) { |
| LBUG(); |
| rc = 0; |
| } else { |
| rc = krb5_encrypt_bulk(kctx->kc_keye.kb_tfm, khdr, |
| conf, desc, &cipher, adj_nob); |
| } |
| |
| if (rc != 0) { |
| rawobj_free(&cksum); |
| return GSS_S_FAILURE; |
| } |
| |
| /* fill in checksum */ |
| LASSERT(token->len >= sizeof(*khdr) + cipher.len + ke->ke_hash_size); |
| memcpy((char *)(khdr + 1) + cipher.len, |
| cksum.data + cksum.len - ke->ke_hash_size, |
| ke->ke_hash_size); |
| rawobj_free(&cksum); |
| |
| /* final token length */ |
| token->len = sizeof(*khdr) + cipher.len + ke->ke_hash_size; |
| return GSS_S_COMPLETE; |
| } |
| |
| static |
| __u32 gss_unwrap_kerberos(struct gss_ctx *gctx, |
| rawobj_t *gsshdr, |
| rawobj_t *token, |
| rawobj_t *msg) |
| { |
| struct krb5_ctx *kctx = gctx->internal_ctx_id; |
| struct krb5_enctype *ke = &enctypes[kctx->kc_enctype]; |
| struct krb5_header *khdr; |
| unsigned char *tmpbuf; |
| int blocksize, bodysize; |
| rawobj_t cksum = RAWOBJ_EMPTY; |
| rawobj_t cipher_in, plain_out; |
| rawobj_t hash_objs[3]; |
| int rc = 0; |
| __u32 major; |
| |
| LASSERT(ke); |
| |
| if (token->len < sizeof(*khdr)) { |
| CERROR("short signature: %u\n", token->len); |
| return GSS_S_DEFECTIVE_TOKEN; |
| } |
| |
| khdr = (struct krb5_header *) token->data; |
| |
| major = verify_krb5_header(kctx, khdr, 1); |
| if (major != GSS_S_COMPLETE) { |
| CERROR("bad krb5 header\n"); |
| return major; |
| } |
| |
| /* block size */ |
| if (kctx->kc_enctype == ENCTYPE_ARCFOUR_HMAC) { |
| LASSERT(kctx->kc_keye.kb_tfm == NULL); |
| blocksize = 1; |
| } else { |
| LASSERT(kctx->kc_keye.kb_tfm); |
| blocksize = ll_crypto_blkcipher_blocksize(kctx->kc_keye.kb_tfm); |
| } |
| |
| /* expected token layout: |
| * ---------------------------------------- |
| * | krb5 header | cipher text | checksum | |
| * ---------------------------------------- |
| */ |
| bodysize = token->len - sizeof(*khdr) - ke->ke_hash_size; |
| |
| if (bodysize % blocksize) { |
| CERROR("odd bodysize %d\n", bodysize); |
| return GSS_S_DEFECTIVE_TOKEN; |
| } |
| |
| if (bodysize <= ke->ke_conf_size + sizeof(*khdr)) { |
| CERROR("incomplete token: bodysize %d\n", bodysize); |
| return GSS_S_DEFECTIVE_TOKEN; |
| } |
| |
| if (msg->len < bodysize - ke->ke_conf_size - sizeof(*khdr)) { |
| CERROR("buffer too small: %u, require %d\n", |
| msg->len, bodysize - ke->ke_conf_size); |
| return GSS_S_FAILURE; |
| } |
| |
| /* decrypting */ |
| OBD_ALLOC_LARGE(tmpbuf, bodysize); |
| if (!tmpbuf) |
| return GSS_S_FAILURE; |
| |
| major = GSS_S_FAILURE; |
| |
| cipher_in.data = (__u8 *) (khdr + 1); |
| cipher_in.len = bodysize; |
| plain_out.data = tmpbuf; |
| plain_out.len = bodysize; |
| |
| if (kctx->kc_enctype == ENCTYPE_ARCFOUR_HMAC) { |
| rawobj_t arc4_keye; |
| struct ll_crypto_cipher *arc4_tfm; |
| |
| cksum.data = token->data + token->len - ke->ke_hash_size; |
| cksum.len = ke->ke_hash_size; |
| |
| if (krb5_make_checksum(ENCTYPE_ARCFOUR_HMAC, &kctx->kc_keyi, |
| NULL, 1, &cksum, 0, NULL, &arc4_keye)) { |
| CERROR("failed to obtain arc4 enc key\n"); |
| GOTO(arc4_out, rc = -EACCES); |
| } |
| |
| arc4_tfm = ll_crypto_alloc_blkcipher("ecb(arc4)", 0, 0); |
| if (IS_ERR(arc4_tfm)) { |
| CERROR("failed to alloc tfm arc4 in ECB mode\n"); |
| GOTO(arc4_out_key, rc = -EACCES); |
| } |
| |
| if (ll_crypto_blkcipher_setkey(arc4_tfm, |
| arc4_keye.data, arc4_keye.len)) { |
| CERROR("failed to set arc4 key, len %d\n", |
| arc4_keye.len); |
| GOTO(arc4_out_tfm, rc = -EACCES); |
| } |
| |
| rc = krb5_encrypt_rawobjs(arc4_tfm, 1, |
| 1, &cipher_in, &plain_out, 0); |
| arc4_out_tfm: |
| ll_crypto_free_blkcipher(arc4_tfm); |
| arc4_out_key: |
| rawobj_free(&arc4_keye); |
| arc4_out: |
| cksum = RAWOBJ_EMPTY; |
| } else { |
| rc = krb5_encrypt_rawobjs(kctx->kc_keye.kb_tfm, 0, |
| 1, &cipher_in, &plain_out, 0); |
| } |
| |
| if (rc != 0) { |
| CERROR("error decrypt\n"); |
| goto out_free; |
| } |
| LASSERT(plain_out.len == bodysize); |
| |
| /* expected clear text layout: |
| * ----------------------------------------- |
| * | confounder | clear msgs | krb5 header | |
| * ----------------------------------------- |
| */ |
| |
| /* verify krb5 header in token is not modified */ |
| if (memcmp(khdr, plain_out.data + plain_out.len - sizeof(*khdr), |
| sizeof(*khdr))) { |
| CERROR("decrypted krb5 header mismatch\n"); |
| goto out_free; |
| } |
| |
| /* verify checksum, compose clear text as layout: |
| * ------------------------------------------------------ |
| * | confounder | gss header | clear msgs | krb5 header | |
| * ------------------------------------------------------ |
| */ |
| hash_objs[0].len = ke->ke_conf_size; |
| hash_objs[0].data = plain_out.data; |
| hash_objs[1].len = gsshdr->len; |
| hash_objs[1].data = gsshdr->data; |
| hash_objs[2].len = plain_out.len - ke->ke_conf_size - sizeof(*khdr); |
| hash_objs[2].data = plain_out.data + ke->ke_conf_size; |
| if (krb5_make_checksum(kctx->kc_enctype, &kctx->kc_keyi, |
| khdr, 3, hash_objs, 0, NULL, &cksum)) |
| goto out_free; |
| |
| LASSERT(cksum.len >= ke->ke_hash_size); |
| if (memcmp((char *)(khdr + 1) + bodysize, |
| cksum.data + cksum.len - ke->ke_hash_size, |
| ke->ke_hash_size)) { |
| CERROR("checksum mismatch\n"); |
| goto out_free; |
| } |
| |
| msg->len = bodysize - ke->ke_conf_size - sizeof(*khdr); |
| memcpy(msg->data, tmpbuf + ke->ke_conf_size, msg->len); |
| |
| major = GSS_S_COMPLETE; |
| out_free: |
| OBD_FREE_LARGE(tmpbuf, bodysize); |
| rawobj_free(&cksum); |
| return major; |
| } |
| |
| static |
| __u32 gss_unwrap_bulk_kerberos(struct gss_ctx *gctx, |
| struct ptlrpc_bulk_desc *desc, |
| rawobj_t *token, int adj_nob) |
| { |
| struct krb5_ctx *kctx = gctx->internal_ctx_id; |
| struct krb5_enctype *ke = &enctypes[kctx->kc_enctype]; |
| struct krb5_header *khdr; |
| int blocksize; |
| rawobj_t cksum = RAWOBJ_EMPTY; |
| rawobj_t cipher, plain; |
| rawobj_t data_desc[1]; |
| int rc; |
| __u32 major; |
| |
| LASSERT(ke); |
| |
| if (token->len < sizeof(*khdr)) { |
| CERROR("short signature: %u\n", token->len); |
| return GSS_S_DEFECTIVE_TOKEN; |
| } |
| |
| khdr = (struct krb5_header *) token->data; |
| |
| major = verify_krb5_header(kctx, khdr, 1); |
| if (major != GSS_S_COMPLETE) { |
| CERROR("bad krb5 header\n"); |
| return major; |
| } |
| |
| /* block size */ |
| if (kctx->kc_enctype == ENCTYPE_ARCFOUR_HMAC) { |
| LASSERT(kctx->kc_keye.kb_tfm == NULL); |
| blocksize = 1; |
| LBUG(); |
| } else { |
| LASSERT(kctx->kc_keye.kb_tfm); |
| blocksize = ll_crypto_blkcipher_blocksize(kctx->kc_keye.kb_tfm); |
| } |
| LASSERT(sizeof(*khdr) >= blocksize && sizeof(*khdr) % blocksize == 0); |
| |
| /* |
| * token format is expected as: |
| * ----------------------------------------------- |
| * | krb5 header | head/tail cipher text | cksum | |
| * ----------------------------------------------- |
| */ |
| if (token->len < sizeof(*khdr) + blocksize + sizeof(*khdr) + |
| ke->ke_hash_size) { |
| CERROR("short token size: %u\n", token->len); |
| return GSS_S_DEFECTIVE_TOKEN; |
| } |
| |
| cipher.data = (__u8 *) (khdr + 1); |
| cipher.len = blocksize + sizeof(*khdr); |
| plain.data = cipher.data; |
| plain.len = cipher.len; |
| |
| rc = krb5_decrypt_bulk(kctx->kc_keye.kb_tfm, khdr, |
| desc, &cipher, &plain, adj_nob); |
| if (rc) |
| return GSS_S_DEFECTIVE_TOKEN; |
| |
| /* |
| * verify checksum, compose clear text as layout: |
| * ------------------------------------------ |
| * | confounder | clear pages | krb5 header | |
| * ------------------------------------------ |
| */ |
| data_desc[0].data = plain.data; |
| data_desc[0].len = blocksize; |
| |
| if (krb5_make_checksum(kctx->kc_enctype, &kctx->kc_keyi, |
| khdr, 1, data_desc, |
| desc->bd_iov_count, desc->bd_iov, |
| &cksum)) |
| return GSS_S_FAILURE; |
| LASSERT(cksum.len >= ke->ke_hash_size); |
| |
| if (memcmp(plain.data + blocksize + sizeof(*khdr), |
| cksum.data + cksum.len - ke->ke_hash_size, |
| ke->ke_hash_size)) { |
| CERROR("checksum mismatch\n"); |
| rawobj_free(&cksum); |
| return GSS_S_BAD_SIG; |
| } |
| |
| rawobj_free(&cksum); |
| return GSS_S_COMPLETE; |
| } |
| |
| int gss_display_kerberos(struct gss_ctx *ctx, |
| char *buf, |
| int bufsize) |
| { |
| struct krb5_ctx *kctx = ctx->internal_ctx_id; |
| int written; |
| |
| written = snprintf(buf, bufsize, "krb5 (%s)", |
| enctype2str(kctx->kc_enctype)); |
| return written; |
| } |
| |
| static struct gss_api_ops gss_kerberos_ops = { |
| .gss_import_sec_context = gss_import_sec_context_kerberos, |
| .gss_copy_reverse_context = gss_copy_reverse_context_kerberos, |
| .gss_inquire_context = gss_inquire_context_kerberos, |
| .gss_get_mic = gss_get_mic_kerberos, |
| .gss_verify_mic = gss_verify_mic_kerberos, |
| .gss_wrap = gss_wrap_kerberos, |
| .gss_unwrap = gss_unwrap_kerberos, |
| .gss_prep_bulk = gss_prep_bulk_kerberos, |
| .gss_wrap_bulk = gss_wrap_bulk_kerberos, |
| .gss_unwrap_bulk = gss_unwrap_bulk_kerberos, |
| .gss_delete_sec_context = gss_delete_sec_context_kerberos, |
| .gss_display = gss_display_kerberos, |
| }; |
| |
| static struct subflavor_desc gss_kerberos_sfs[] = { |
| { |
| .sf_subflavor = SPTLRPC_SUBFLVR_KRB5N, |
| .sf_qop = 0, |
| .sf_service = SPTLRPC_SVC_NULL, |
| .sf_name = "krb5n" |
| }, |
| { |
| .sf_subflavor = SPTLRPC_SUBFLVR_KRB5A, |
| .sf_qop = 0, |
| .sf_service = SPTLRPC_SVC_AUTH, |
| .sf_name = "krb5a" |
| }, |
| { |
| .sf_subflavor = SPTLRPC_SUBFLVR_KRB5I, |
| .sf_qop = 0, |
| .sf_service = SPTLRPC_SVC_INTG, |
| .sf_name = "krb5i" |
| }, |
| { |
| .sf_subflavor = SPTLRPC_SUBFLVR_KRB5P, |
| .sf_qop = 0, |
| .sf_service = SPTLRPC_SVC_PRIV, |
| .sf_name = "krb5p" |
| }, |
| }; |
| |
| /* |
| * currently we leave module owner NULL |
| */ |
| static struct gss_api_mech gss_kerberos_mech = { |
| .gm_owner = NULL, /*THIS_MODULE, */ |
| .gm_name = "krb5", |
| .gm_oid = (rawobj_t) |
| {9, "\052\206\110\206\367\022\001\002\002"}, |
| .gm_ops = &gss_kerberos_ops, |
| .gm_sf_num = 4, |
| .gm_sfs = gss_kerberos_sfs, |
| }; |
| |
| int __init init_kerberos_module(void) |
| { |
| int status; |
| |
| spin_lock_init(&krb5_seq_lock); |
| |
| status = lgss_mech_register(&gss_kerberos_mech); |
| if (status) |
| CERROR("Failed to register kerberos gss mechanism!\n"); |
| return status; |
| } |
| |
| void __exit cleanup_kerberos_module(void) |
| { |
| lgss_mech_unregister(&gss_kerberos_mech); |
| } |