b3d10e7ccd7e9344a80764f3f1d87f37c4cf68c4
[linux-2.6.git] / net / rxrpc / ar-key.c
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-type.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
26 static int rxrpc_instantiate(struct key *, const void *, size_t);
27 static int rxrpc_instantiate_s(struct key *, const void *, size_t);
28 static void rxrpc_destroy(struct key *);
29 static void rxrpc_destroy_s(struct key *);
30 static 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  */
36 struct 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 EXPORT_SYMBOL(key_type_rxrpc);
44
45 /*
46  * rxrpc server defined keys take "<serviceId>:<securityIndex>" as the
47  * description and an 8-byte decryption key as the payload
48  */
49 struct key_type key_type_rxrpc_s = {
50         .name           = "rxrpc_s",
51         .instantiate    = rxrpc_instantiate_s,
52         .match          = user_match,
53         .destroy        = rxrpc_destroy_s,
54         .describe       = rxrpc_describe,
55 };
56
57 /*
58  * instantiate an rxrpc defined key
59  * data should be of the form:
60  *      OFFSET  LEN     CONTENT
61  *      0       4       key interface version number
62  *      4       2       security index (type)
63  *      6       2       ticket length
64  *      8       4       key expiry time (time_t)
65  *      12      4       kvno
66  *      16      8       session key
67  *      24      [len]   ticket
68  *
69  * if no data is provided, then a no-security key is made
70  */
71 static int rxrpc_instantiate(struct key *key, const void *data, size_t datalen)
72 {
73         const struct rxkad_key *tsec;
74         struct rxrpc_key_payload *upayload;
75         size_t plen;
76         u32 kver;
77         int ret;
78
79         _enter("{%x},,%zu", key_serial(key), datalen);
80
81         /* handle a no-security key */
82         if (!data && datalen == 0)
83                 return 0;
84
85         /* get the key interface version number */
86         ret = -EINVAL;
87         if (datalen <= 4 || !data)
88                 goto error;
89         memcpy(&kver, data, sizeof(kver));
90         data += sizeof(kver);
91         datalen -= sizeof(kver);
92
93         _debug("KEY I/F VERSION: %u", kver);
94
95         ret = -EKEYREJECTED;
96         if (kver != 1)
97                 goto error;
98
99         /* deal with a version 1 key */
100         ret = -EINVAL;
101         if (datalen < sizeof(*tsec))
102                 goto error;
103
104         tsec = data;
105         if (datalen != sizeof(*tsec) + tsec->ticket_len)
106                 goto error;
107
108         _debug("SCIX: %u", tsec->security_index);
109         _debug("TLEN: %u", tsec->ticket_len);
110         _debug("EXPY: %x", tsec->expiry);
111         _debug("KVNO: %u", tsec->kvno);
112         _debug("SKEY: %02x%02x%02x%02x%02x%02x%02x%02x",
113                tsec->session_key[0], tsec->session_key[1],
114                tsec->session_key[2], tsec->session_key[3],
115                tsec->session_key[4], tsec->session_key[5],
116                tsec->session_key[6], tsec->session_key[7]);
117         if (tsec->ticket_len >= 8)
118                 _debug("TCKT: %02x%02x%02x%02x%02x%02x%02x%02x",
119                        tsec->ticket[0], tsec->ticket[1],
120                        tsec->ticket[2], tsec->ticket[3],
121                        tsec->ticket[4], tsec->ticket[5],
122                        tsec->ticket[6], tsec->ticket[7]);
123
124         ret = -EPROTONOSUPPORT;
125         if (tsec->security_index != RXRPC_SECURITY_RXKAD)
126                 goto error;
127
128         key->type_data.x[0] = tsec->security_index;
129
130         plen = sizeof(*upayload) + tsec->ticket_len;
131         ret = key_payload_reserve(key, plen);
132         if (ret < 0)
133                 goto error;
134
135         ret = -ENOMEM;
136         upayload = kmalloc(plen, GFP_KERNEL);
137         if (!upayload)
138                 goto error;
139
140         /* attach the data */
141         memcpy(&upayload->k, tsec, sizeof(*tsec));
142         memcpy(&upayload->k.ticket, (void *)tsec + sizeof(*tsec),
143                tsec->ticket_len);
144         key->payload.data = upayload;
145         key->expiry = tsec->expiry;
146         ret = 0;
147
148 error:
149         return ret;
150 }
151
152 /*
153  * instantiate a server secret key
154  * data should be a pointer to the 8-byte secret key
155  */
156 static int rxrpc_instantiate_s(struct key *key, const void *data,
157                                size_t datalen)
158 {
159         struct crypto_blkcipher *ci;
160
161         _enter("{%x},,%zu", key_serial(key), datalen);
162
163         if (datalen != 8)
164                 return -EINVAL;
165
166         memcpy(&key->type_data, data, 8);
167
168         ci = crypto_alloc_blkcipher("pcbc(des)", 0, CRYPTO_ALG_ASYNC);
169         if (IS_ERR(ci)) {
170                 _leave(" = %ld", PTR_ERR(ci));
171                 return PTR_ERR(ci);
172         }
173
174         if (crypto_blkcipher_setkey(ci, data, 8) < 0)
175                 BUG();
176
177         key->payload.data = ci;
178         _leave(" = 0");
179         return 0;
180 }
181
182 /*
183  * dispose of the data dangling from the corpse of a rxrpc key
184  */
185 static void rxrpc_destroy(struct key *key)
186 {
187         kfree(key->payload.data);
188 }
189
190 /*
191  * dispose of the data dangling from the corpse of a rxrpc key
192  */
193 static void rxrpc_destroy_s(struct key *key)
194 {
195         if (key->payload.data) {
196                 crypto_free_blkcipher(key->payload.data);
197                 key->payload.data = NULL;
198         }
199 }
200
201 /*
202  * describe the rxrpc key
203  */
204 static void rxrpc_describe(const struct key *key, struct seq_file *m)
205 {
206         seq_puts(m, key->description);
207 }
208
209 /*
210  * grab the security key for a socket
211  */
212 int rxrpc_request_key(struct rxrpc_sock *rx, char __user *optval, int optlen)
213 {
214         struct key *key;
215         char *description;
216
217         _enter("");
218
219         if (optlen <= 0 || optlen > PAGE_SIZE - 1)
220                 return -EINVAL;
221
222         description = kmalloc(optlen + 1, GFP_KERNEL);
223         if (!description)
224                 return -ENOMEM;
225
226         if (copy_from_user(description, optval, optlen)) {
227                 kfree(description);
228                 return -EFAULT;
229         }
230         description[optlen] = 0;
231
232         key = request_key(&key_type_rxrpc, description, NULL);
233         if (IS_ERR(key)) {
234                 kfree(description);
235                 _leave(" = %ld", PTR_ERR(key));
236                 return PTR_ERR(key);
237         }
238
239         rx->key = key;
240         kfree(description);
241         _leave(" = 0 [key %x]", key->serial);
242         return 0;
243 }
244
245 /*
246  * grab the security keyring for a server socket
247  */
248 int rxrpc_server_keyring(struct rxrpc_sock *rx, char __user *optval,
249                          int optlen)
250 {
251         struct key *key;
252         char *description;
253
254         _enter("");
255
256         if (optlen <= 0 || optlen > PAGE_SIZE - 1)
257                 return -EINVAL;
258
259         description = kmalloc(optlen + 1, GFP_KERNEL);
260         if (!description)
261                 return -ENOMEM;
262
263         if (copy_from_user(description, optval, optlen)) {
264                 kfree(description);
265                 return -EFAULT;
266         }
267         description[optlen] = 0;
268
269         key = request_key(&key_type_keyring, description, NULL);
270         if (IS_ERR(key)) {
271                 kfree(description);
272                 _leave(" = %ld", PTR_ERR(key));
273                 return PTR_ERR(key);
274         }
275
276         rx->securities = key;
277         kfree(description);
278         _leave(" = 0 [key %x]", key->serial);
279         return 0;
280 }
281
282 /*
283  * generate a server data key
284  */
285 int rxrpc_get_server_data_key(struct rxrpc_connection *conn,
286                               const void *session_key,
287                               time_t expiry,
288                               u32 kvno)
289 {
290         const struct cred *cred = current_cred();
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, cred, 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 = RXRPC_SECURITY_RXKAD;
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
327 error:
328         key_revoke(key);
329         key_put(key);
330         _leave(" = -ENOMEM [ins %d]", ret);
331         return -ENOMEM;
332 }
333 EXPORT_SYMBOL(rxrpc_get_server_data_key);
334
335 /**
336  * rxrpc_get_null_key - Generate a null RxRPC key
337  * @keyname: The name to give the key.
338  *
339  * Generate a null RxRPC key that can be used to indicate anonymous security is
340  * required for a particular domain.
341  */
342 struct key *rxrpc_get_null_key(const char *keyname)
343 {
344         const struct cred *cred = current_cred();
345         struct key *key;
346         int ret;
347
348         key = key_alloc(&key_type_rxrpc, keyname, 0, 0, cred,
349                         KEY_POS_SEARCH, KEY_ALLOC_NOT_IN_QUOTA);
350         if (IS_ERR(key))
351                 return key;
352
353         ret = key_instantiate_and_link(key, NULL, 0, NULL, NULL);
354         if (ret < 0) {
355                 key_revoke(key);
356                 key_put(key);
357                 return ERR_PTR(ret);
358         }
359
360         return key;
361 }
362 EXPORT_SYMBOL(rxrpc_get_null_key);