blob: 66b1840b4110b6ee876af85c8ba598a3054a43f8 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/* user_defined.c: user defined key type
2 *
3 * Copyright (C) 2004 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
12#include <linux/module.h>
13#include <linux/init.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070014#include <linux/slab.h>
15#include <linux/seq_file.h>
16#include <linux/err.h>
David Howells2aa349f2005-10-30 15:02:42 -080017#include <keys/user-type.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070018#include <asm/uaccess.h>
19#include "internal.h"
20
Jeff Layton9f6ed2c2012-01-17 16:09:11 -050021static int logon_vet_description(const char *desc);
22
Linus Torvalds1da177e2005-04-16 15:20:36 -070023/*
24 * user defined keys take an arbitrary string as the description and an
25 * arbitrary blob of data as the payload
26 */
27struct key_type key_type_user = {
David Howells4bdf0bc2013-09-24 10:35:15 +010028 .name = "user",
David Howellsf9167782014-07-18 18:56:35 +010029 .preparse = user_preparse,
30 .free_preparse = user_free_preparse,
31 .instantiate = generic_key_instantiate,
David Howells4bdf0bc2013-09-24 10:35:15 +010032 .update = user_update,
David Howells4bdf0bc2013-09-24 10:35:15 +010033 .revoke = user_revoke,
34 .destroy = user_destroy,
35 .describe = user_describe,
36 .read = user_read,
Linus Torvalds1da177e2005-04-16 15:20:36 -070037};
38
Michael Halcrow16c29b62005-06-23 22:00:58 -070039EXPORT_SYMBOL_GPL(key_type_user);
40
Linus Torvalds1da177e2005-04-16 15:20:36 -070041/*
Jeff Layton9f6ed2c2012-01-17 16:09:11 -050042 * This key type is essentially the same as key_type_user, but it does
43 * not define a .read op. This is suitable for storing username and
44 * password pairs in the keyring that you do not want to be readable
45 * from userspace.
46 */
47struct key_type key_type_logon = {
48 .name = "logon",
David Howellsf9167782014-07-18 18:56:35 +010049 .preparse = user_preparse,
50 .free_preparse = user_free_preparse,
51 .instantiate = generic_key_instantiate,
Jeff Layton9f6ed2c2012-01-17 16:09:11 -050052 .update = user_update,
Jeff Layton9f6ed2c2012-01-17 16:09:11 -050053 .revoke = user_revoke,
54 .destroy = user_destroy,
55 .describe = user_describe,
56 .vet_description = logon_vet_description,
57};
58EXPORT_SYMBOL_GPL(key_type_logon);
59
60/*
David Howellsf9167782014-07-18 18:56:35 +010061 * Preparse a user defined key payload
Linus Torvalds1da177e2005-04-16 15:20:36 -070062 */
David Howellsf9167782014-07-18 18:56:35 +010063int user_preparse(struct key_preparsed_payload *prep)
Linus Torvalds1da177e2005-04-16 15:20:36 -070064{
David Howells76d8aea2005-06-23 22:00:49 -070065 struct user_key_payload *upayload;
David Howellscf7f6012012-09-13 13:06:29 +010066 size_t datalen = prep->datalen;
Linus Torvalds1da177e2005-04-16 15:20:36 -070067
David Howellscf7f6012012-09-13 13:06:29 +010068 if (datalen <= 0 || datalen > 32767 || !prep->data)
David Howellsf9167782014-07-18 18:56:35 +010069 return -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -070070
David Howells76d8aea2005-06-23 22:00:49 -070071 upayload = kmalloc(sizeof(*upayload) + datalen, GFP_KERNEL);
72 if (!upayload)
David Howellsf9167782014-07-18 18:56:35 +010073 return -ENOMEM;
Linus Torvalds1da177e2005-04-16 15:20:36 -070074
David Howells76d8aea2005-06-23 22:00:49 -070075 /* attach the data */
David Howellsf9167782014-07-18 18:56:35 +010076 prep->quotalen = datalen;
David Howells146aa8b2015-10-21 14:04:48 +010077 prep->payload.data[0] = upayload;
David Howells76d8aea2005-06-23 22:00:49 -070078 upayload->datalen = datalen;
David Howellscf7f6012012-09-13 13:06:29 +010079 memcpy(upayload->data, prep->data, datalen);
David Howellsf9167782014-07-18 18:56:35 +010080 return 0;
David Howellsa8b17ed2011-01-20 16:38:27 +000081}
David Howellsf9167782014-07-18 18:56:35 +010082EXPORT_SYMBOL_GPL(user_preparse);
David Howells31204ed2006-06-26 00:24:51 -070083
David Howellsf9167782014-07-18 18:56:35 +010084/*
85 * Free a preparse of a user defined key payload
86 */
87void user_free_preparse(struct key_preparsed_payload *prep)
88{
David Howells146aa8b2015-10-21 14:04:48 +010089 kfree(prep->payload.data[0]);
David Howellsf9167782014-07-18 18:56:35 +010090}
91EXPORT_SYMBOL_GPL(user_free_preparse);
David Howells2aa349f2005-10-30 15:02:42 -080092
Linus Torvalds1da177e2005-04-16 15:20:36 -070093/*
Linus Torvalds1da177e2005-04-16 15:20:36 -070094 * update a user defined key
David Howells76d8aea2005-06-23 22:00:49 -070095 * - the key's semaphore is write-locked
Linus Torvalds1da177e2005-04-16 15:20:36 -070096 */
David Howellscf7f6012012-09-13 13:06:29 +010097int user_update(struct key *key, struct key_preparsed_payload *prep)
Linus Torvalds1da177e2005-04-16 15:20:36 -070098{
David Howells898de7d2016-04-12 19:54:58 +010099 struct user_key_payload *zap = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700100 int ret;
101
Linus Torvalds1da177e2005-04-16 15:20:36 -0700102 /* check the quota and attach the new data */
David Howells898de7d2016-04-12 19:54:58 +0100103 ret = key_payload_reserve(key, prep->datalen);
104 if (ret < 0)
105 return ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700106
David Howells898de7d2016-04-12 19:54:58 +0100107 /* attach the new data, displacing the old */
108 key->expiry = prep->expiry;
109 if (!test_bit(KEY_FLAG_NEGATIVE, &key->flags))
110 zap = rcu_dereference_key(key);
111 rcu_assign_keypointer(key, prep->payload.data[0]);
112 prep->payload.data[0] = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700113
David Howells9f35a332011-11-15 22:09:45 +0000114 if (zap)
115 kfree_rcu(zap, rcu);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700116 return ret;
David Howellsa8b17ed2011-01-20 16:38:27 +0000117}
David Howells2aa349f2005-10-30 15:02:42 -0800118EXPORT_SYMBOL_GPL(user_update);
119
Linus Torvalds1da177e2005-04-16 15:20:36 -0700120/*
David Howells31204ed2006-06-26 00:24:51 -0700121 * dispose of the links from a revoked keyring
122 * - called with the key sem write-locked
123 */
124void user_revoke(struct key *key)
125{
David Howells146aa8b2015-10-21 14:04:48 +0100126 struct user_key_payload *upayload = key->payload.data[0];
David Howells31204ed2006-06-26 00:24:51 -0700127
128 /* clear the quota */
129 key_payload_reserve(key, 0);
130
131 if (upayload) {
Mimi Zoharf6b24572012-01-18 10:03:14 +0000132 rcu_assign_keypointer(key, NULL);
Lai Jiangshan3acb4582011-03-18 12:11:07 +0800133 kfree_rcu(upayload, rcu);
David Howells31204ed2006-06-26 00:24:51 -0700134 }
David Howellsa8b17ed2011-01-20 16:38:27 +0000135}
David Howells31204ed2006-06-26 00:24:51 -0700136
137EXPORT_SYMBOL(user_revoke);
138
David Howells31204ed2006-06-26 00:24:51 -0700139/*
140 * dispose of the data dangling from the corpse of a user key
Linus Torvalds1da177e2005-04-16 15:20:36 -0700141 */
David Howells2aa349f2005-10-30 15:02:42 -0800142void user_destroy(struct key *key)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700143{
David Howells146aa8b2015-10-21 14:04:48 +0100144 struct user_key_payload *upayload = key->payload.data[0];
David Howells76d8aea2005-06-23 22:00:49 -0700145
146 kfree(upayload);
David Howellsa8b17ed2011-01-20 16:38:27 +0000147}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700148
David Howells2aa349f2005-10-30 15:02:42 -0800149EXPORT_SYMBOL_GPL(user_destroy);
150
Linus Torvalds1da177e2005-04-16 15:20:36 -0700151/*
David Howells76d8aea2005-06-23 22:00:49 -0700152 * describe the user key
Linus Torvalds1da177e2005-04-16 15:20:36 -0700153 */
David Howells2aa349f2005-10-30 15:02:42 -0800154void user_describe(const struct key *key, struct seq_file *m)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700155{
156 seq_puts(m, key->description);
David Howells78b72802011-03-11 17:57:23 +0000157 if (key_is_instantiated(key))
158 seq_printf(m, ": %u", key->datalen);
David Howellsa8b17ed2011-01-20 16:38:27 +0000159}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700160
David Howells2aa349f2005-10-30 15:02:42 -0800161EXPORT_SYMBOL_GPL(user_describe);
162
Linus Torvalds1da177e2005-04-16 15:20:36 -0700163/*
164 * read the key data
David Howells76d8aea2005-06-23 22:00:49 -0700165 * - the key's semaphore is read-locked
Linus Torvalds1da177e2005-04-16 15:20:36 -0700166 */
David Howells2aa349f2005-10-30 15:02:42 -0800167long user_read(const struct key *key, char __user *buffer, size_t buflen)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700168{
David Howells146aa8b2015-10-21 14:04:48 +0100169 const struct user_key_payload *upayload;
David Howells76d8aea2005-06-23 22:00:49 -0700170 long ret;
171
David Howells146aa8b2015-10-21 14:04:48 +0100172 upayload = user_key_payload(key);
David Howells76d8aea2005-06-23 22:00:49 -0700173 ret = upayload->datalen;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700174
175 /* we can return the data as is */
176 if (buffer && buflen > 0) {
David Howells76d8aea2005-06-23 22:00:49 -0700177 if (buflen > upayload->datalen)
178 buflen = upayload->datalen;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700179
David Howells76d8aea2005-06-23 22:00:49 -0700180 if (copy_to_user(buffer, upayload->data, buflen) != 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700181 ret = -EFAULT;
182 }
183
184 return ret;
David Howellsa8b17ed2011-01-20 16:38:27 +0000185}
David Howells2aa349f2005-10-30 15:02:42 -0800186
187EXPORT_SYMBOL_GPL(user_read);
Jeff Layton9f6ed2c2012-01-17 16:09:11 -0500188
189/* Vet the description for a "logon" key */
190static int logon_vet_description(const char *desc)
191{
192 char *p;
193
194 /* require a "qualified" description string */
195 p = strchr(desc, ':');
196 if (!p)
197 return -EINVAL;
198
199 /* also reject description with ':' as first char */
200 if (p == desc)
201 return -EINVAL;
202
203 return 0;
204}