Google Git
Sign in
gfiber / kernel / lockdown / 11371619d9b072287570a47e3cfcb7b1519b4ca6 / . / drivers / staging / lustre / lustre / ptlrpc / gss / gss_krb5_mech.c
blob: b9fa3b4a40dbad20ecf6f01f2e0a6257b84ddcff [file] [log] [blame]
/*
* 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 <linux/crypto.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 = 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 (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)
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, "successfully 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, "successfully 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, "successfully 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 crypto_blkcipher *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 % crypto_blkcipher_blocksize(tfm) != 0) {
CERROR("output length %d mismatch blocksize %d\n",
length, crypto_blkcipher_blocksize(tfm));
goto out;
}
if (crypto_blkcipher_ivsize(tfm) > 16) {
CERROR("iv size too large %d\n", crypto_blkcipher_ivsize(tfm));
goto out;
}
if (iv)
memcpy(local_iv, iv, crypto_blkcipher_ivsize(tfm));
memcpy(out, in, length);
buf_to_sg(&sg, out, length);
if (decrypt)
ret = crypto_blkcipher_decrypt_iv(&desc, &sg, &sg, length);
else
ret = crypto_blkcipher_encrypt_iv(&desc, &sg, &sg, length);
out:
return(ret);
}
static inline
int krb5_digest_hmac(struct 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;
crypto_hash_setkey(tfm, key->data, key->len);
desc.tfm = tfm;
desc.flags= 0;
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);
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);
crypto_hash_update(&desc, sg, iovs[i].kiov_len);
}
if (khdr) {
buf_to_sg(sg, (char *) khdr, sizeof(*khdr));
crypto_hash_update(&desc, sg, sizeof(*khdr));
}
return crypto_hash_final(&desc, cksum->data);
}
static inline
int krb5_digest_norm(struct 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;
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);
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);
crypto_hash_update(&desc, sg, iovs[i].kiov_len);
}
if (khdr) {
buf_to_sg(sg, (char *) khdr, sizeof(*khdr));
crypto_hash_update(&desc, sg, sizeof(*khdr));
}
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 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 = 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:
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 crypto_blkcipher *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;
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 = crypto_blkcipher_encrypt(
&desc, &dst, &src, src.length);
else
rc = crypto_blkcipher_decrypt(
&desc, &dst, &src, src.length);
} else {
if (enc)
rc = crypto_blkcipher_encrypt_iv(
&desc, &dst, &src, src.length);
else
rc = 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 crypto_blkcipher *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 = 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 = 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 = 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 = 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 crypto_blkcipher *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 = 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 = 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 = 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 = 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 >=
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 = 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 crypto_blkcipher *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 = 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 (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:
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 = 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 = 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 = 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 crypto_blkcipher *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 = 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 (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:
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 = 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);
}