1/*
2 *   fs/cifs/cifs_spnego.c -- SPNEGO upcall management for CIFS
3 *
4 *   Copyright (c) 2007 Red Hat, Inc.
5 *   Author(s): Jeff Layton (jlayton@redhat.com)
6 *
7 *   This library is free software; you can redistribute it and/or modify
8 *   it under the terms of the GNU Lesser General Public License as published
9 *   by the Free Software Foundation; either version 2.1 of the License, or
10 *   (at your option) any later version.
11 *
12 *   This library is distributed in the hope that it will be useful,
13 *   but WITHOUT ANY WARRANTY; without even the implied warranty of
14 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See
15 *   the GNU Lesser General Public License for more details.
16 *
17 *   You should have received a copy of the GNU Lesser General Public License
18 *   along with this library; if not, write to the Free Software
19 *   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
20 */
21
22#include <linux/list.h>
23#include <linux/slab.h>
24#include <linux/string.h>
25#include <keys/user-type.h>
26#include <linux/key-type.h>
27#include <linux/keyctl.h>
28#include <linux/inet.h>
29#include "cifsglob.h"
30#include "cifs_spnego.h"
31#include "cifs_debug.h"
32#include "cifsproto.h"
33static const struct cred *spnego_cred;
34
35/* create a new cifs key */
36static int
37cifs_spnego_key_instantiate(struct key *key, struct key_preparsed_payload *prep)
38{
39	char *payload;
40	int ret;
41
42	ret = -ENOMEM;
43	payload = kmemdup(prep->data, prep->datalen, GFP_KERNEL);
44	if (!payload)
45		goto error;
46
47	/* attach the data */
48	key->payload.data = payload;
49	ret = 0;
50
51error:
52	return ret;
53}
54
55static void
56cifs_spnego_key_destroy(struct key *key)
57{
58	kfree(key->payload.data);
59}
60
61
62/*
63 * keytype for CIFS spnego keys
64 */
65struct key_type cifs_spnego_key_type = {
66	.name		= "cifs.spnego",
67	.instantiate	= cifs_spnego_key_instantiate,
68	.destroy	= cifs_spnego_key_destroy,
69	.describe	= user_describe,
70};
71
72/* length of longest version string e.g.  strlen("ver=0xFF") */
73#define MAX_VER_STR_LEN		8
74
75/* length of longest security mechanism name, eg in future could have
76 * strlen(";sec=ntlmsspi") */
77#define MAX_MECH_STR_LEN	13
78
79/* strlen of "host=" */
80#define HOST_KEY_LEN		5
81
82/* strlen of ";ip4=" or ";ip6=" */
83#define IP_KEY_LEN		5
84
85/* strlen of ";uid=0x" */
86#define UID_KEY_LEN		7
87
88/* strlen of ";creduid=0x" */
89#define CREDUID_KEY_LEN		11
90
91/* strlen of ";user=" */
92#define USER_KEY_LEN		6
93
94/* strlen of ";pid=0x" */
95#define PID_KEY_LEN		7
96
97/* get a key struct with a SPNEGO security blob, suitable for session setup */
98struct key *
99cifs_get_spnego_key(struct cifs_ses *sesInfo)
100{
101	struct TCP_Server_Info *server = sesInfo->server;
102	struct sockaddr_in *sa = (struct sockaddr_in *) &server->dstaddr;
103	struct sockaddr_in6 *sa6 = (struct sockaddr_in6 *) &server->dstaddr;
104	char *description, *dp;
105	size_t desc_len;
106	struct key *spnego_key;
107	const char *hostname = server->hostname;
108	const struct cred *saved_cred;
109
110	/* length of fields (with semicolons): ver=0xyz ip4=ipaddress
111	   host=hostname sec=mechanism uid=0xFF user=username */
112	desc_len = MAX_VER_STR_LEN +
113		   HOST_KEY_LEN + strlen(hostname) +
114		   IP_KEY_LEN + INET6_ADDRSTRLEN +
115		   MAX_MECH_STR_LEN +
116		   UID_KEY_LEN + (sizeof(uid_t) * 2) +
117		   CREDUID_KEY_LEN + (sizeof(uid_t) * 2) +
118		   PID_KEY_LEN + (sizeof(pid_t) * 2) + 1;
119
120	if (sesInfo->user_name)
121		desc_len += USER_KEY_LEN + strlen(sesInfo->user_name);
122
123	spnego_key = ERR_PTR(-ENOMEM);
124	description = kzalloc(desc_len, GFP_KERNEL);
125	if (description == NULL)
126		goto out;
127
128	dp = description;
129	/* start with version and hostname portion of UNC string */
130	spnego_key = ERR_PTR(-EINVAL);
131	sprintf(dp, "ver=0x%x;host=%s;", CIFS_SPNEGO_UPCALL_VERSION,
132		hostname);
133	dp = description + strlen(description);
134
135	/* add the server address */
136	if (server->dstaddr.ss_family == AF_INET)
137		sprintf(dp, "ip4=%pI4", &sa->sin_addr);
138	else if (server->dstaddr.ss_family == AF_INET6)
139		sprintf(dp, "ip6=%pI6", &sa6->sin6_addr);
140	else
141		goto out;
142
143	dp = description + strlen(description);
144
145	/* for now, only sec=krb5 and sec=mskrb5 are valid */
146	if (server->sec_kerberos)
147		sprintf(dp, ";sec=krb5");
148	else if (server->sec_mskerberos)
149		sprintf(dp, ";sec=mskrb5");
150	else
151		goto out;
152
153	dp = description + strlen(description);
154	sprintf(dp, ";uid=0x%x",
155		from_kuid_munged(&init_user_ns, sesInfo->linux_uid));
156
157	dp = description + strlen(description);
158	sprintf(dp, ";creduid=0x%x",
159		from_kuid_munged(&init_user_ns, sesInfo->cred_uid));
160
161	if (sesInfo->user_name) {
162		dp = description + strlen(description);
163		sprintf(dp, ";user=%s", sesInfo->user_name);
164	}
165
166	dp = description + strlen(description);
167	sprintf(dp, ";pid=0x%x", current->pid);
168
169	cifs_dbg(FYI, "key description = %s\n", description);
170	saved_cred = override_creds(spnego_cred);
171	spnego_key = request_key(&cifs_spnego_key_type, description, "");
172	revert_creds(saved_cred);
173
174#ifdef CONFIG_CIFS_DEBUG2
175	if (cifsFYI && !IS_ERR(spnego_key)) {
176		struct cifs_spnego_msg *msg = spnego_key->payload.data;
177		cifs_dump_mem("SPNEGO reply blob:", msg->data, min(1024U,
178				msg->secblob_len + msg->sesskey_len));
179	}
180#endif /* CONFIG_CIFS_DEBUG2 */
181
182out:
183	kfree(description);
184	return spnego_key;
185}
186
187int
188init_cifs_spnego(void)
189{
190	struct cred *cred;
191	struct key *keyring;
192	int ret;
193
194	cifs_dbg(FYI, "Registering the %s key type\n",
195		 cifs_spnego_key_type.name);
196
197	/*
198	 * Create an override credential set with special thread keyring for
199	 * spnego upcalls.
200	 */
201
202	cred = prepare_kernel_cred(NULL);
203	if (!cred)
204		return -ENOMEM;
205
206	keyring = keyring_alloc(".cifs_spnego",
207				GLOBAL_ROOT_UID, GLOBAL_ROOT_GID, cred,
208				(KEY_POS_ALL & ~KEY_POS_SETATTR) |
209				KEY_USR_VIEW | KEY_USR_READ,
210				KEY_ALLOC_NOT_IN_QUOTA, NULL);
211	if (IS_ERR(keyring)) {
212		ret = PTR_ERR(keyring);
213		goto failed_put_cred;
214	}
215
216	ret = register_key_type(&cifs_spnego_key_type);
217	if (ret < 0)
218		goto failed_put_key;
219
220	/*
221	 * instruct request_key() to use this special keyring as a cache for
222	 * the results it looks up
223	 */
224	set_bit(KEY_FLAG_ROOT_CAN_CLEAR, &keyring->flags);
225	cred->thread_keyring = keyring;
226	cred->jit_keyring = KEY_REQKEY_DEFL_THREAD_KEYRING;
227	spnego_cred = cred;
228
229	cifs_dbg(FYI, "cifs spnego keyring: %d\n", key_serial(keyring));
230	return 0;
231
232failed_put_key:
233	key_put(keyring);
234failed_put_cred:
235	put_cred(cred);
236	return ret;
237}
238
239void
240exit_cifs_spnego(void)
241{
242	key_revoke(spnego_cred->thread_keyring);
243	unregister_key_type(&cifs_spnego_key_type);
244	put_cred(spnego_cred);
245	cifs_dbg(FYI, "Unregistered %s key type\n", cifs_spnego_key_type.name);
246}
247