SUNRPC: Add RPC based upcall mechanism for RPCGSS auth

obj-$(CONFIG_SUNRPC_GSS) += auth_rpcgss.o

obj-$(CONFIG_SUNRPC_GSS) += auth_rpcgss.o

auth_rpcgss-y := auth_gss.o gss_generic_token.o \

auth_rpcgss-y := auth_gss.o gss_generic_token.o \

	gss_mech_switch.o svcauth_gss.o

	gss_mech_switch.o svcauth_gss.o \

	gss_rpc_upcall.o gss_rpc_xdr.o

obj-$(CONFIG_RPCSEC_GSS_KRB5) += rpcsec_gss_krb5.o

obj-$(CONFIG_RPCSEC_GSS_KRB5) += rpcsec_gss_krb5.o

/*

 *  linux/net/sunrpc/gss_rpc_upcall.c

 *

 *  Copyright (C) 2012 Simo Sorce <simo@redhat.com>

 *

 * This program is free software; you can redistribute it and/or modify

 * it under the terms of the GNU General Public License as published by

 * the Free Software Foundation; either version 2 of the License, or

 * (at your option) any later version.

 *

 * This program is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 * GNU General Public License for more details.

 *

 * You should have received a copy of the GNU General Public License

 * along with this program; if not, write to the Free Software

 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.

 */

#include <linux/types.h>

#include <linux/un.h>

#include <linux/sunrpc/svcauth.h>

#include "gss_rpc_upcall.h"

#define GSSPROXY_SOCK_PATHNAME	"/var/run/gssproxy.sock"

#define GSSPROXY_PROGRAM	(400112u)

#define GSSPROXY_VERS_1		(1u)

/*

 * Encoding/Decoding functions

 */

enum {

	GSSX_NULL = 0,	/* Unused */

        GSSX_INDICATE_MECHS = 1,

        GSSX_GET_CALL_CONTEXT = 2,

        GSSX_IMPORT_AND_CANON_NAME = 3,

        GSSX_EXPORT_CRED = 4,

        GSSX_IMPORT_CRED = 5,

        GSSX_ACQUIRE_CRED = 6,

        GSSX_STORE_CRED = 7,

        GSSX_INIT_SEC_CONTEXT = 8,

        GSSX_ACCEPT_SEC_CONTEXT = 9,

        GSSX_RELEASE_HANDLE = 10,

        GSSX_GET_MIC = 11,

        GSSX_VERIFY = 12,

        GSSX_WRAP = 13,

        GSSX_UNWRAP = 14,

        GSSX_WRAP_SIZE_LIMIT = 15,

};

#define PROC(proc, name)				\

[GSSX_##proc] = {					\

	.p_proc   = GSSX_##proc,			\

	.p_encode = (kxdreproc_t)gssx_enc_##name,	\

	.p_decode = (kxdrdproc_t)gssx_dec_##name,	\

	.p_arglen = GSSX_ARG_##name##_sz,		\

	.p_replen = GSSX_RES_##name##_sz, 		\

	.p_statidx = GSSX_##proc,			\

	.p_name   = #proc,				\

}

struct rpc_procinfo gssp_procedures[] = {

	PROC(INDICATE_MECHS, indicate_mechs),

        PROC(GET_CALL_CONTEXT, get_call_context),

        PROC(IMPORT_AND_CANON_NAME, import_and_canon_name),

        PROC(EXPORT_CRED, export_cred),

        PROC(IMPORT_CRED, import_cred),

        PROC(ACQUIRE_CRED, acquire_cred),

        PROC(STORE_CRED, store_cred),

        PROC(INIT_SEC_CONTEXT, init_sec_context),

        PROC(ACCEPT_SEC_CONTEXT, accept_sec_context),

        PROC(RELEASE_HANDLE, release_handle),

        PROC(GET_MIC, get_mic),

        PROC(VERIFY, verify),

        PROC(WRAP, wrap),

        PROC(UNWRAP, unwrap),

        PROC(WRAP_SIZE_LIMIT, wrap_size_limit),

};

/*

 * Common transport functions

 */

static const struct rpc_program gssp_program;

static int gssp_rpc_create(struct net *net, struct rpc_clnt **_clnt)

{

	static const struct sockaddr_un gssp_localaddr = {

		.sun_family		= AF_LOCAL,

		.sun_path		= GSSPROXY_SOCK_PATHNAME,

	};

	struct rpc_create_args args = {

		.net		= net,

		.protocol	= XPRT_TRANSPORT_LOCAL,

		.address	= (struct sockaddr *)&gssp_localaddr,

		.addrsize	= sizeof(gssp_localaddr),

		.servername	= "localhost",

		.program	= &gssp_program,

		.version	= GSSPROXY_VERS_1,

		.authflavor	= RPC_AUTH_NULL,

		/*

		 * Note we want connection to be done in the caller's

		 * filesystem namespace.  We therefore turn off the idle

		 * timeout, which would result in reconnections being

		 * done without the correct namespace:

		 */

		.flags		= RPC_CLNT_CREATE_NOPING |

				  RPC_CLNT_CREATE_NO_IDLE_TIMEOUT

	};

	struct rpc_clnt *clnt;

	int result = 0;

	clnt = rpc_create(&args);

	if (IS_ERR(clnt)) {

		dprintk("RPC:       failed to create AF_LOCAL gssproxy "

				"client (errno %ld).\n", PTR_ERR(clnt));

		result = -PTR_ERR(clnt);

		*_clnt = NULL;

		goto out;

	}

	dprintk("RPC:       created new gssp local client (gssp_local_clnt: "

			"%p)\n", clnt);

	*_clnt = clnt;

out:

	return result;

}

void init_gssp_clnt(struct sunrpc_net *sn)

{

	mutex_init(&sn->gssp_lock);

	sn->gssp_clnt = NULL;

}

int set_gssp_clnt(struct net *net)

{

	struct sunrpc_net *sn = net_generic(net, sunrpc_net_id);

	struct rpc_clnt *clnt;

	int ret;

	mutex_lock(&sn->gssp_lock);

	ret = gssp_rpc_create(net, &clnt);

	if (!ret) {

		if (sn->gssp_clnt)

			rpc_shutdown_client(sn->gssp_clnt);

		sn->gssp_clnt = clnt;

	}

	mutex_unlock(&sn->gssp_lock);

	return ret;

}

void clear_gssp_clnt(struct sunrpc_net *sn)

{

	mutex_lock(&sn->gssp_lock);

	if (sn->gssp_clnt) {

		rpc_shutdown_client(sn->gssp_clnt);

		sn->gssp_clnt = NULL;

	}

	mutex_unlock(&sn->gssp_lock);

}

static struct rpc_clnt *get_gssp_clnt(struct sunrpc_net *sn)

{

	struct rpc_clnt *clnt;

	mutex_lock(&sn->gssp_lock);

	clnt = sn->gssp_clnt;

	if (clnt)

		atomic_inc(&clnt->cl_count);

	mutex_unlock(&sn->gssp_lock);

	return clnt;

}

static int gssp_call(struct net *net, struct rpc_message *msg)

{

	struct sunrpc_net *sn = net_generic(net, sunrpc_net_id);

	struct rpc_clnt *clnt;

	int status;

	clnt = get_gssp_clnt(sn);

	if (!clnt)

		return -EIO;

	status = rpc_call_sync(clnt, msg, 0);

	if (status < 0) {

		dprintk("gssp: rpc_call returned error %d\n", -status);

		switch (status) {

		case -EPROTONOSUPPORT:

			status = -EINVAL;

			break;

		case -ECONNREFUSED:

		case -ETIMEDOUT:

		case -ENOTCONN:

			status = -EAGAIN;

			break;

		case -ERESTARTSYS:

			if (signalled ())

				status = -EINTR;

			break;

		default:

			break;

		}

	}

	rpc_release_client(clnt);

	return status;

}

/*

 * Public functions

 */

/* numbers somewhat arbitrary but large enough for current needs */

#define GSSX_MAX_OUT_HANDLE	128

#define GSSX_MAX_MECH_OID	16

#define GSSX_MAX_SRC_PRINC	256

#define GSSX_KMEMBUF (GSSX_max_output_handle_sz + \

			GSSX_max_oid_sz + \

			GSSX_max_princ_sz + \

			sizeof(struct svc_cred))

int gssp_accept_sec_context_upcall(struct net *net,

				struct gssp_upcall_data *data)

{

	struct gssx_ctx ctxh = {

		.state = data->in_handle

	};

	struct gssx_arg_accept_sec_context arg = {

		.input_token = data->in_token,

	};

	struct gssx_ctx rctxh = {

		/*

		 * pass in the max length we expect for each of these

		 * buffers but let the xdr code kmalloc them:

		 */

		.exported_context_token.len = GSSX_max_output_handle_sz,

		.mech.len = GSSX_max_oid_sz,

		.src_name.display_name.len = GSSX_max_princ_sz

	};

	struct gssx_res_accept_sec_context res = {

		.context_handle = &rctxh,

		.output_token = &data->out_token

	};

	struct rpc_message msg = {

		.rpc_proc = &gssp_procedures[GSSX_ACCEPT_SEC_CONTEXT],

		.rpc_argp = &arg,

		.rpc_resp = &res,

		.rpc_cred = NULL, /* FIXME ? */

	};

	struct xdr_netobj client_name = { 0 , NULL };

	int ret;

	if (data->in_handle.len != 0)

		arg.context_handle = &ctxh;

	res.output_token->len = GSSX_max_output_token_sz;

	/* use nfs/ for targ_name ? */

	ret = gssp_call(net, &msg);

	/* we need to fetch all data even in case of error so

	 * that we can free special strctures is they have been allocated */

	data->major_status = res.status.major_status;

	data->minor_status = res.status.minor_status;

	if (res.context_handle) {

		data->out_handle = rctxh.exported_context_token;

		data->mech_oid = rctxh.mech;

		client_name = rctxh.src_name.display_name;

	}

	if (res.options.count == 1) {

		gssx_buffer *value = &res.options.data[0].value;

		/* Currently we only decode CREDS_VALUE, if we add

		 * anything else we'll have to loop and match on the

		 * option name */

		if (value->len == 1) {

			/* steal group info from struct svc_cred */

			data->creds = *(struct svc_cred *)value->data;

			data->found_creds = 1;

		}

		/* whether we use it or not, free data */

		kfree(value->data);

	}

	if (res.options.count != 0) {

		kfree(res.options.data);

	}

	/* convert to GSS_NT_HOSTBASED_SERVICE form and set into creds */

	if (data->found_creds && client_name.data != NULL) {

		char *c;

		data->creds.cr_principal = kstrndup(client_name.data,

						client_name.len, GFP_KERNEL);

		if (data->creds.cr_principal) {

			/* terminate and remove realm part */

			c = strchr(data->creds.cr_principal, '@');

			if (c) {

				*c = '\0';

				/* change service-hostname delimiter */

				c = strchr(data->creds.cr_principal, '/');

				if (c) *c = '@';

			}

			if (!c) {

				/* not a service principal */

				kfree(data->creds.cr_principal);

				data->creds.cr_principal = NULL;

			}

		}

	}

	kfree(client_name.data);

	return ret;

}

void gssp_free_upcall_data(struct gssp_upcall_data *data)

{

	kfree(data->in_handle.data);

	kfree(data->out_handle.data);

	kfree(data->out_token.data);

	kfree(data->mech_oid.data);

	free_svc_cred(&data->creds);

}

/*

 * Initialization stuff

 */

static const struct rpc_version gssp_version1 = {

	.number		= GSSPROXY_VERS_1,

	.nrprocs	= ARRAY_SIZE(gssp_procedures),

	.procs		= gssp_procedures,

};

static const struct rpc_version *gssp_version[] = {

	NULL,

	&gssp_version1,

};

static struct rpc_stat gssp_stats;

static const struct rpc_program gssp_program = {

	.name		= "gssproxy",

	.number		= GSSPROXY_PROGRAM,

	.nrvers		= ARRAY_SIZE(gssp_version),

	.version	= gssp_version,

	.stats		= &gssp_stats,

};

/*

 *  linux/net/sunrpc/gss_rpc_upcall.h

 *

 *  Copyright (C) 2012 Simo Sorce <simo@redhat.com>

 *

 * This program is free software; you can redistribute it and/or modify

 * it under the terms of the GNU General Public License as published by

 * the Free Software Foundation; either version 2 of the License, or

 * (at your option) any later version.

 *

 * This program is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 * GNU General Public License for more details.

 *

 * You should have received a copy of the GNU General Public License

 * along with this program; if not, write to the Free Software

 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.

 */

#ifndef _GSS_RPC_UPCALL_H

#define _GSS_RPC_UPCALL_H

#include <linux/sunrpc/auth_gss.h>

#include "gss_rpc_xdr.h"

#include "../netns.h"

struct gssp_upcall_data {

	struct xdr_netobj in_handle;

	struct gssp_in_token in_token;

	struct xdr_netobj out_handle;

	struct xdr_netobj out_token;

	struct xdr_netobj mech_oid;

	struct svc_cred creds;

	int found_creds;

	int major_status;

	int minor_status;

};

int gssp_accept_sec_context_upcall(struct net *net,

				struct gssp_upcall_data *data);

void gssp_free_upcall_data(struct gssp_upcall_data *data);

void init_gssp_clnt(struct sunrpc_net *);

int set_gssp_clnt(struct net *);

void clear_gssp_clnt(struct sunrpc_net *);

#endif /* _GSS_RPC_UPCALL_H */

/*

 * GSS Proxy upcall module

 *

 *  Copyright (C) 2012 Simo Sorce <simo@redhat.com>

 *

 * This program is free software; you can redistribute it and/or modify

 * it under the terms of the GNU General Public License as published by

 * the Free Software Foundation; either version 2 of the License, or

 * (at your option) any later version.

 *

 * This program is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 * GNU General Public License for more details.

 *

 * You should have received a copy of the GNU General Public License

 * along with this program; if not, write to the Free Software

 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.

 */

#ifndef _LINUX_GSS_RPC_XDR_H

#define _LINUX_GSS_RPC_XDR_H

#include <linux/sunrpc/xdr.h>

#include <linux/sunrpc/clnt.h>

#include <linux/sunrpc/xprtsock.h>

#ifdef RPC_DEBUG

# define RPCDBG_FACILITY	RPCDBG_AUTH

#endif

#define LUCID_OPTION "exported_context_type"

#define LUCID_VALUE  "linux_lucid_v1"

#define CREDS_OPTION "exported_creds_type"

#define CREDS_VALUE  "linux_creds_v1"

typedef struct xdr_netobj gssx_buffer;

typedef struct xdr_netobj utf8string;

typedef struct xdr_netobj gssx_OID;

enum gssx_cred_usage {

	GSSX_C_INITIATE = 1,

	GSSX_C_ACCEPT = 2,

	GSSX_C_BOTH = 3,

};

struct gssx_option {

	gssx_buffer option;

	gssx_buffer value;

};

struct gssx_option_array {

	u32 count;

	struct gssx_option *data;

};

struct gssx_status {

	u64 major_status;

	gssx_OID mech;

	u64 minor_status;

	utf8string major_status_string;

	utf8string minor_status_string;

	gssx_buffer server_ctx;

	struct gssx_option_array options;

};

struct gssx_call_ctx {

	utf8string locale;

	gssx_buffer server_ctx;

	struct gssx_option_array options;

};

struct gssx_name_attr {

	gssx_buffer attr;

	gssx_buffer value;

	struct gssx_option_array extensions;

};

struct gssx_name_attr_array {

	u32 count;

	struct gssx_name_attr *data;

};

struct gssx_name {

	gssx_buffer display_name;

};

typedef struct gssx_name gssx_name;

struct gssx_cred_element {

	gssx_name MN;

	gssx_OID mech;

	u32 cred_usage;

	u64 initiator_time_rec;

	u64 acceptor_time_rec;

	struct gssx_option_array options;

};

struct gssx_cred_element_array {

	u32 count;

	struct gssx_cred_element *data;

};

struct gssx_cred {

	gssx_name desired_name;

	struct gssx_cred_element_array elements;

	gssx_buffer cred_handle_reference;

	u32 needs_release;

};

struct gssx_ctx {

	gssx_buffer exported_context_token;

	gssx_buffer state;

	u32 need_release;

	gssx_OID mech;

	gssx_name src_name;

	gssx_name targ_name;

	u64 lifetime;

	u64 ctx_flags;

	u32 locally_initiated;

	u32 open;

	struct gssx_option_array options;

};

struct gssx_cb {

	u64 initiator_addrtype;

	gssx_buffer initiator_address;

	u64 acceptor_addrtype;

	gssx_buffer acceptor_address;

	gssx_buffer application_data;

};

/* This structure is not defined in the protocol.

 * It is used in the kernel to carry around a big buffer

 * as a set of pages */

struct gssp_in_token {

	struct page **pages;	/* Array of contiguous pages */

	unsigned int page_base;	/* Start of page data */

	unsigned int page_len;	/* Length of page data */

};

struct gssx_arg_accept_sec_context {

	struct gssx_call_ctx call_ctx;

	struct gssx_ctx *context_handle;

	struct gssx_cred *cred_handle;

	struct gssp_in_token input_token;

	struct gssx_cb *input_cb;

	u32 ret_deleg_cred;

	struct gssx_option_array options;

};

struct gssx_res_accept_sec_context {

	struct gssx_status status;

	struct gssx_ctx *context_handle;

	gssx_buffer *output_token;

	/* struct gssx_cred *delegated_cred_handle; not used in kernel */

	struct gssx_option_array options;

};

#define gssx_enc_indicate_mechs NULL

#define gssx_dec_indicate_mechs NULL

#define gssx_enc_get_call_context NULL

#define gssx_dec_get_call_context NULL

#define gssx_enc_import_and_canon_name NULL

#define gssx_dec_import_and_canon_name NULL

#define gssx_enc_export_cred NULL

#define gssx_dec_export_cred NULL

#define gssx_enc_import_cred NULL

#define gssx_dec_import_cred NULL

#define gssx_enc_acquire_cred NULL

#define gssx_dec_acquire_cred NULL

#define gssx_enc_store_cred NULL

#define gssx_dec_store_cred NULL

#define gssx_enc_init_sec_context NULL

#define gssx_dec_init_sec_context NULL

void gssx_enc_accept_sec_context(struct rpc_rqst *req,

				 struct xdr_stream *xdr,

				 struct gssx_arg_accept_sec_context *args);

int gssx_dec_accept_sec_context(struct rpc_rqst *rqstp,

				struct xdr_stream *xdr,

				struct gssx_res_accept_sec_context *res);

#define gssx_enc_release_handle NULL

#define gssx_dec_release_handle NULL

#define gssx_enc_get_mic NULL

#define gssx_dec_get_mic NULL

#define gssx_enc_verify NULL

#define gssx_dec_verify NULL

#define gssx_enc_wrap NULL

#define gssx_dec_wrap NULL

#define gssx_enc_unwrap NULL

#define gssx_dec_unwrap NULL

#define gssx_enc_wrap_size_limit NULL

#define gssx_dec_wrap_size_limit NULL

/* non implemented calls are set to 0 size */

#define GSSX_ARG_indicate_mechs_sz 0

#define GSSX_RES_indicate_mechs_sz 0

#define GSSX_ARG_get_call_context_sz 0

#define GSSX_RES_get_call_context_sz 0

#define GSSX_ARG_import_and_canon_name_sz 0

#define GSSX_RES_import_and_canon_name_sz 0

#define GSSX_ARG_export_cred_sz 0

#define GSSX_RES_export_cred_sz 0

#define GSSX_ARG_import_cred_sz 0

#define GSSX_RES_import_cred_sz 0

#define GSSX_ARG_acquire_cred_sz 0

#define GSSX_RES_acquire_cred_sz 0

#define GSSX_ARG_store_cred_sz 0

#define GSSX_RES_store_cred_sz 0

#define GSSX_ARG_init_sec_context_sz 0

#define GSSX_RES_init_sec_context_sz 0

#define GSSX_default_in_call_ctx_sz (4 + 4 + 4 + \

			8 + sizeof(LUCID_OPTION) + sizeof(LUCID_VALUE) + \

			8 + sizeof(CREDS_OPTION) + sizeof(CREDS_VALUE))

#define GSSX_default_in_ctx_hndl_sz (4 + 4+8 + 4 + 4 + 6*4 + 6*4 + 8 + 8 + \

					4 + 4 + 4)

#define GSSX_default_in_cred_sz 4 /* we send in no cred_handle */

#define GSSX_default_in_token_sz 4 /* does *not* include token data */

#define GSSX_default_in_cb_sz 4 /* we do not use channel bindings */

#define GSSX_ARG_accept_sec_context_sz (GSSX_default_in_call_ctx_sz + \

					GSSX_default_in_ctx_hndl_sz + \

					GSSX_default_in_cred_sz + \

					GSSX_default_in_token_sz + \

					GSSX_default_in_cb_sz + \

					4 /* no deleg creds boolean */ + \

					4) /* empty options */

/* somewhat arbitrary numbers but large enough (we ignore some of the data

 * sent down, but it is part of the protocol so we need enough space to take

 * it in) */

#define GSSX_default_status_sz 8 + 24 + 8 + 256 + 256 + 16 + 4

#define GSSX_max_output_handle_sz 128

#define GSSX_max_oid_sz 16

#define GSSX_max_princ_sz 256

#define GSSX_default_ctx_sz (GSSX_max_output_handle_sz + \

			     16 + 4 + GSSX_max_oid_sz + \

			     2 * GSSX_max_princ_sz + \

			     8 + 8 + 4 + 4 + 4)

#define GSSX_max_output_token_sz 1024

#define GSSX_max_creds_sz (4 + 4 + 4 + NGROUPS_MAX * 4)

#define GSSX_RES_accept_sec_context_sz (GSSX_default_status_sz + \

					GSSX_default_ctx_sz + \

					GSSX_max_output_token_sz + \

					4 + GSSX_max_creds_sz)

#define GSSX_ARG_release_handle_sz 0

#define GSSX_RES_release_handle_sz 0

#define GSSX_ARG_get_mic_sz 0

#define GSSX_RES_get_mic_sz 0

#define GSSX_ARG_verify_sz 0

#define GSSX_RES_verify_sz 0

#define GSSX_ARG_wrap_sz 0

#define GSSX_RES_wrap_sz 0

#define GSSX_ARG_unwrap_sz 0

#define GSSX_RES_unwrap_sz 0

#define GSSX_ARG_wrap_size_limit_sz 0

#define GSSX_RES_wrap_size_limit_sz 0

#endif /* _LINUX_GSS_RPC_XDR_H */