0ecc2e8d2bd0f6ca82da683e895a869f61ad3190
[linux-3.10.git] / security / keys / request_key_auth.c
1 /* request_key_auth.c: request key authorisation controlling key def
2  *
3  * Copyright (C) 2005 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  * See Documentation/keys-request-key.txt
12  */
13
14 #include <linux/module.h>
15 #include <linux/sched.h>
16 #include <linux/err.h>
17 #include <linux/seq_file.h>
18 #include <asm/uaccess.h>
19 #include "internal.h"
20
21 static int request_key_auth_instantiate(struct key *, const void *, size_t);
22 static void request_key_auth_describe(const struct key *, struct seq_file *);
23 static void request_key_auth_destroy(struct key *);
24 static long request_key_auth_read(const struct key *, char __user *, size_t);
25
26 /*
27  * the request-key authorisation key type definition
28  */
29 struct key_type key_type_request_key_auth = {
30         .name           = ".request_key_auth",
31         .def_datalen    = sizeof(struct request_key_auth),
32         .instantiate    = request_key_auth_instantiate,
33         .describe       = request_key_auth_describe,
34         .destroy        = request_key_auth_destroy,
35         .read           = request_key_auth_read,
36 };
37
38 /*****************************************************************************/
39 /*
40  * instantiate a request-key authorisation key
41  */
42 static int request_key_auth_instantiate(struct key *key,
43                                         const void *data,
44                                         size_t datalen)
45 {
46         key->payload.data = (struct request_key_auth *) data;
47         return 0;
48
49 } /* end request_key_auth_instantiate() */
50
51 /*****************************************************************************/
52 /*
53  * reading a request-key authorisation key retrieves the callout information
54  */
55 static void request_key_auth_describe(const struct key *key,
56                                       struct seq_file *m)
57 {
58         struct request_key_auth *rka = key->payload.data;
59
60         seq_puts(m, "key:");
61         seq_puts(m, key->description);
62         seq_printf(m, " pid:%d ci:%zu", rka->pid, strlen(rka->callout_info));
63
64 } /* end request_key_auth_describe() */
65
66 /*****************************************************************************/
67 /*
68  * read the callout_info data
69  * - the key's semaphore is read-locked
70  */
71 static long request_key_auth_read(const struct key *key,
72                                   char __user *buffer, size_t buflen)
73 {
74         struct request_key_auth *rka = key->payload.data;
75         size_t datalen;
76         long ret;
77
78         datalen = strlen(rka->callout_info);
79         ret = datalen;
80
81         /* we can return the data as is */
82         if (buffer && buflen > 0) {
83                 if (buflen > datalen)
84                         buflen = datalen;
85
86                 if (copy_to_user(buffer, rka->callout_info, buflen) != 0)
87                         ret = -EFAULT;
88         }
89
90         return ret;
91
92 } /* end request_key_auth_read() */
93
94 /*****************************************************************************/
95 /*
96  * destroy an instantiation authorisation token key
97  */
98 static void request_key_auth_destroy(struct key *key)
99 {
100         struct request_key_auth *rka = key->payload.data;
101
102         kenter("{%d}", key->serial);
103
104         key_put(rka->target_key);
105         kfree(rka);
106
107 } /* end request_key_auth_destroy() */
108
109 /*****************************************************************************/
110 /*
111  * create an authorisation token for /sbin/request-key or whoever to gain
112  * access to the caller's security data
113  */
114 struct key *request_key_auth_new(struct key *target, const char *callout_info)
115 {
116         struct request_key_auth *rka, *irka;
117         struct key *authkey = NULL;
118         char desc[20];
119         int ret;
120
121         kenter("%d,", target->serial);
122
123         /* allocate a auth record */
124         rka = kmalloc(sizeof(*rka), GFP_KERNEL);
125         if (!rka) {
126                 kleave(" = -ENOMEM");
127                 return ERR_PTR(-ENOMEM);
128         }
129
130         /* see if the calling process is already servicing the key request of
131          * another process */
132         if (current->request_key_auth) {
133                 /* it is - use that instantiation context here too */
134                 irka = current->request_key_auth->payload.data;
135                 rka->context = irka->context;
136                 rka->pid = irka->pid;
137         }
138         else {
139                 /* it isn't - use this process as the context */
140                 rka->context = current;
141                 rka->pid = current->pid;
142         }
143
144         rka->target_key = key_get(target);
145         rka->callout_info = callout_info;
146
147         /* allocate the auth key */
148         sprintf(desc, "%x", target->serial);
149
150         authkey = key_alloc(&key_type_request_key_auth, desc,
151                             current->fsuid, current->fsgid, current,
152                             KEY_POS_VIEW | KEY_POS_READ | KEY_POS_SEARCH |
153                             KEY_USR_VIEW, 1);
154         if (IS_ERR(authkey)) {
155                 ret = PTR_ERR(authkey);
156                 goto error_alloc;
157         }
158
159         /* construct and attach to the keyring */
160         ret = key_instantiate_and_link(authkey, rka, 0, NULL, NULL);
161         if (ret < 0)
162                 goto error_inst;
163
164         kleave(" = {%d})", authkey->serial);
165         return authkey;
166
167 error_inst:
168         key_revoke(authkey);
169         key_put(authkey);
170 error_alloc:
171         key_put(rka->target_key);
172         kfree(rka);
173         kleave("= %d", ret);
174         return ERR_PTR(ret);
175
176 } /* end request_key_auth_new() */
177
178 /*****************************************************************************/
179 /*
180  * see if an authorisation key is associated with a particular key
181  */
182 static int key_get_instantiation_authkey_match(const struct key *key,
183                                                const void *_id)
184 {
185         struct request_key_auth *rka = key->payload.data;
186         key_serial_t id = (key_serial_t)(unsigned long) _id;
187
188         return rka->target_key->serial == id;
189
190 } /* end key_get_instantiation_authkey_match() */
191
192 /*****************************************************************************/
193 /*
194  * get the authorisation key for instantiation of a specific key if attached to
195  * the current process's keyrings
196  * - this key is inserted into a keyring and that is set as /sbin/request-key's
197  *   session keyring
198  * - a target_id of zero specifies any valid token
199  */
200 struct key *key_get_instantiation_authkey(key_serial_t target_id)
201 {
202         struct key *authkey;
203         key_ref_t authkey_ref;
204
205         authkey_ref = search_process_keyrings(
206                 &key_type_request_key_auth,
207                 (void *) (unsigned long) target_id,
208                 key_get_instantiation_authkey_match,
209                 current);
210
211         if (IS_ERR(authkey_ref)) {
212                 authkey = ERR_PTR(PTR_ERR(authkey_ref));
213                 goto error;
214         }
215
216         authkey = key_ref_to_ptr(authkey_ref);
217         if (test_bit(KEY_FLAG_REVOKED, &authkey->flags)) {
218                 key_put(authkey);
219                 authkey = ERR_PTR(-EKEYREVOKED);
220         }
221
222 error:
223         return authkey;
224
225 } /* end key_get_instantiation_authkey() */