1/* RxRPC key management
2 *
3 * Copyright (C) 2007 Red Hat, Inc. All Rights Reserved.
4 * Written by David Howells (dhowells@redhat.com)
5 *
6 * This program is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU General Public License
8 * as published by the Free Software Foundation; either version
9 * 2 of the License, or (at your option) any later version.
10 *
11 * RxRPC keys should have a description of describing their purpose:
12 *	"afs@CAMBRIDGE.REDHAT.COM>
13 */
14
15#include <linux/module.h>
16#include <linux/net.h>
17#include <linux/skbuff.h>
18#include <linux/key.h>
19#include <linux/crypto.h>
20#include <net/sock.h>
21#include <net/af_rxrpc.h>
22#include <keys/rxrpc-type.h>
23#include <keys/user-type.h>
24#include "ar-internal.h"
25
26static int rxrpc_instantiate(struct key *, const void *, size_t);
27static int rxrpc_instantiate_s(struct key *, const void *, size_t);
28static void rxrpc_destroy(struct key *);
29static void rxrpc_destroy_s(struct key *);
30static void rxrpc_describe(const struct key *, struct seq_file *);
31
32/*
33 * rxrpc defined keys take an arbitrary string as the description and an
34 * arbitrary blob of data as the payload
35 */
36struct key_type key_type_rxrpc = {
37	.name		= "rxrpc",
38	.instantiate	= rxrpc_instantiate,
39	.match		= user_match,
40	.destroy	= rxrpc_destroy,
41	.describe	= rxrpc_describe,
42};
43
44EXPORT_SYMBOL(key_type_rxrpc);
45
46/*
47 * rxrpc server defined keys take "<serviceId>:<securityIndex>" as the
48 * description and an 8-byte decryption key as the payload
49 */
50struct key_type key_type_rxrpc_s = {
51	.name		= "rxrpc_s",
52	.instantiate	= rxrpc_instantiate_s,
53	.match		= user_match,
54	.destroy	= rxrpc_destroy_s,
55	.describe	= rxrpc_describe,
56};
57
58/*
59 * instantiate an rxrpc defined key
60 * data should be of the form:
61 *	OFFSET	LEN	CONTENT
62 *	0	4	key interface version number
63 *	4	2	security index (type)
64 *	6	2	ticket length
65 *	8	4	key expiry time (time_t)
66 *	12	4	kvno
67 *	16	8	session key
68 *	24	[len]	ticket
69 *
70 * if no data is provided, then a no-security key is made
71 */
72static int rxrpc_instantiate(struct key *key, const void *data, size_t datalen)
73{
74	const struct rxkad_key *tsec;
75	struct rxrpc_key_payload *upayload;
76	size_t plen;
77	u32 kver;
78	int ret;
79
80	_enter("{%x},,%zu", key_serial(key), datalen);
81
82	/* handle a no-security key */
83	if (!data && datalen == 0)
84		return 0;
85
86	/* get the key interface version number */
87	ret = -EINVAL;
88	if (datalen <= 4 || !data)
89		goto error;
90	memcpy(&kver, data, sizeof(kver));
91	data += sizeof(kver);
92	datalen -= sizeof(kver);
93
94	_debug("KEY I/F VERSION: %u", kver);
95
96	ret = -EKEYREJECTED;
97	if (kver != 1)
98		goto error;
99
100	/* deal with a version 1 key */
101	ret = -EINVAL;
102	if (datalen < sizeof(*tsec))
103		goto error;
104
105	tsec = data;
106	if (datalen != sizeof(*tsec) + tsec->ticket_len)
107		goto error;
108
109	_debug("SCIX: %u", tsec->security_index);
110	_debug("TLEN: %u", tsec->ticket_len);
111	_debug("EXPY: %x", tsec->expiry);
112	_debug("KVNO: %u", tsec->kvno);
113	_debug("SKEY: %02x%02x%02x%02x%02x%02x%02x%02x",
114	       tsec->session_key[0], tsec->session_key[1],
115	       tsec->session_key[2], tsec->session_key[3],
116	       tsec->session_key[4], tsec->session_key[5],
117	       tsec->session_key[6], tsec->session_key[7]);
118	if (tsec->ticket_len >= 8)
119		_debug("TCKT: %02x%02x%02x%02x%02x%02x%02x%02x",
120		       tsec->ticket[0], tsec->ticket[1],
121		       tsec->ticket[2], tsec->ticket[3],
122		       tsec->ticket[4], tsec->ticket[5],
123		       tsec->ticket[6], tsec->ticket[7]);
124
125	ret = -EPROTONOSUPPORT;
126	if (tsec->security_index != 2)
127		goto error;
128
129	key->type_data.x[0] = tsec->security_index;
130
131	plen = sizeof(*upayload) + tsec->ticket_len;
132	ret = key_payload_reserve(key, plen);
133	if (ret < 0)
134		goto error;
135
136	ret = -ENOMEM;
137	upayload = kmalloc(plen, GFP_KERNEL);
138	if (!upayload)
139		goto error;
140
141	/* attach the data */
142	memcpy(&upayload->k, tsec, sizeof(*tsec));
143	memcpy(&upayload->k.ticket, (void *)tsec + sizeof(*tsec),
144	       tsec->ticket_len);
145	key->payload.data = upayload;
146	key->expiry = tsec->expiry;
147	ret = 0;
148
149error:
150	return ret;
151}
152
153/*
154 * instantiate a server secret key
155 * data should be a pointer to the 8-byte secret key
156 */
157static int rxrpc_instantiate_s(struct key *key, const void *data,
158			       size_t datalen)
159{
160	struct crypto_blkcipher *ci;
161
162	_enter("{%x},,%zu", key_serial(key), datalen);
163
164	if (datalen != 8)
165		return -EINVAL;
166
167	memcpy(&key->type_data, data, 8);
168
169	ci = crypto_alloc_blkcipher("pcbc(des)", 0, CRYPTO_ALG_ASYNC);
170	if (IS_ERR(ci)) {
171		_leave(" = %ld", PTR_ERR(ci));
172		return PTR_ERR(ci);
173	}
174
175	if (crypto_blkcipher_setkey(ci, data, 8) < 0)
176		BUG();
177
178	key->payload.data = ci;
179	_leave(" = 0");
180	return 0;
181}
182
183/*
184 * dispose of the data dangling from the corpse of a rxrpc key
185 */
186static void rxrpc_destroy(struct key *key)
187{
188	kfree(key->payload.data);
189}
190
191/*
192 * dispose of the data dangling from the corpse of a rxrpc key
193 */
194static void rxrpc_destroy_s(struct key *key)
195{
196	if (key->payload.data) {
197		crypto_free_blkcipher(key->payload.data);
198		key->payload.data = NULL;
199	}
200}
201
202/*
203 * describe the rxrpc key
204 */
205static void rxrpc_describe(const struct key *key, struct seq_file *m)
206{
207	seq_puts(m, key->description);
208}
209
210/*
211 * grab the security key for a socket
212 */
213int rxrpc_request_key(struct rxrpc_sock *rx, char __user *optval, int optlen)
214{
215	struct key *key;
216	char *description;
217
218	_enter("");
219
220	if (optlen <= 0 || optlen > PAGE_SIZE - 1)
221		return -EINVAL;
222
223	description = kmalloc(optlen + 1, GFP_KERNEL);
224	if (!description)
225		return -ENOMEM;
226
227	if (copy_from_user(description, optval, optlen)) {
228		kfree(description);
229		return -EFAULT;
230	}
231	description[optlen] = 0;
232
233	key = request_key(&key_type_rxrpc, description, NULL);
234	if (IS_ERR(key)) {
235		kfree(description);
236		_leave(" = %ld", PTR_ERR(key));
237		return PTR_ERR(key);
238	}
239
240	rx->key = key;
241	kfree(description);
242	_leave(" = 0 [key %x]", key->serial);
243	return 0;
244}
245
246/*
247 * grab the security keyring for a server socket
248 */
249int rxrpc_server_keyring(struct rxrpc_sock *rx, char __user *optval,
250			 int optlen)
251{
252	struct key *key;
253	char *description;
254
255	_enter("");
256
257	if (optlen <= 0 || optlen > PAGE_SIZE - 1)
258		return -EINVAL;
259
260	description = kmalloc(optlen + 1, GFP_KERNEL);
261	if (!description)
262		return -ENOMEM;
263
264	if (copy_from_user(description, optval, optlen)) {
265		kfree(description);
266		return -EFAULT;
267	}
268	description[optlen] = 0;
269
270	key = request_key(&key_type_keyring, description, NULL);
271	if (IS_ERR(key)) {
272		kfree(description);
273		_leave(" = %ld", PTR_ERR(key));
274		return PTR_ERR(key);
275	}
276
277	rx->securities = key;
278	kfree(description);
279	_leave(" = 0 [key %x]", key->serial);
280	return 0;
281}
282
283/*
284 * generate a server data key
285 */
286int rxrpc_get_server_data_key(struct rxrpc_connection *conn,
287			      const void *session_key,
288			      time_t expiry,
289			      u32 kvno)
290{
291	struct key *key;
292	int ret;
293
294	struct {
295		u32 kver;
296		struct rxkad_key tsec;
297	} data;
298
299	_enter("");
300
301	key = key_alloc(&key_type_rxrpc, "x", 0, 0, current, 0,
302			KEY_ALLOC_NOT_IN_QUOTA);
303	if (IS_ERR(key)) {
304		_leave(" = -ENOMEM [alloc %ld]", PTR_ERR(key));
305		return -ENOMEM;
306	}
307
308	_debug("key %d", key_serial(key));
309
310	data.kver = 1;
311	data.tsec.security_index = 2;
312	data.tsec.ticket_len = 0;
313	data.tsec.expiry = expiry;
314	data.tsec.kvno = 0;
315
316	memcpy(&data.tsec.session_key, session_key,
317	       sizeof(data.tsec.session_key));
318
319	ret = key_instantiate_and_link(key, &data, sizeof(data), NULL, NULL);
320	if (ret < 0)
321		goto error;
322
323	conn->key = key;
324	_leave(" = 0 [%d]", key_serial(key));
325	return 0;
326
327error:
328	key_revoke(key);
329	key_put(key);
330	_leave(" = -ENOMEM [ins %d]", ret);
331	return -ENOMEM;
332}
333
334EXPORT_SYMBOL(rxrpc_get_server_data_key);
335