xref: /openbmc/linux/security/keys/user_defined.c (revision a06c488d)
1 /* 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>
14 #include <linux/slab.h>
15 #include <linux/seq_file.h>
16 #include <linux/err.h>
17 #include <keys/user-type.h>
18 #include <asm/uaccess.h>
19 #include "internal.h"
20 
21 static int logon_vet_description(const char *desc);
22 
23 /*
24  * user defined keys take an arbitrary string as the description and an
25  * arbitrary blob of data as the payload
26  */
27 struct key_type key_type_user = {
28 	.name			= "user",
29 	.preparse		= user_preparse,
30 	.free_preparse		= user_free_preparse,
31 	.instantiate		= generic_key_instantiate,
32 	.update			= user_update,
33 	.revoke			= user_revoke,
34 	.destroy		= user_destroy,
35 	.describe		= user_describe,
36 	.read			= user_read,
37 };
38 
39 EXPORT_SYMBOL_GPL(key_type_user);
40 
41 /*
42  * 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  */
47 struct key_type key_type_logon = {
48 	.name			= "logon",
49 	.preparse		= user_preparse,
50 	.free_preparse		= user_free_preparse,
51 	.instantiate		= generic_key_instantiate,
52 	.update			= user_update,
53 	.revoke			= user_revoke,
54 	.destroy		= user_destroy,
55 	.describe		= user_describe,
56 	.vet_description	= logon_vet_description,
57 };
58 EXPORT_SYMBOL_GPL(key_type_logon);
59 
60 /*
61  * Preparse a user defined key payload
62  */
63 int user_preparse(struct key_preparsed_payload *prep)
64 {
65 	struct user_key_payload *upayload;
66 	size_t datalen = prep->datalen;
67 
68 	if (datalen <= 0 || datalen > 32767 || !prep->data)
69 		return -EINVAL;
70 
71 	upayload = kmalloc(sizeof(*upayload) + datalen, GFP_KERNEL);
72 	if (!upayload)
73 		return -ENOMEM;
74 
75 	/* attach the data */
76 	prep->quotalen = datalen;
77 	prep->payload.data[0] = upayload;
78 	upayload->datalen = datalen;
79 	memcpy(upayload->data, prep->data, datalen);
80 	return 0;
81 }
82 EXPORT_SYMBOL_GPL(user_preparse);
83 
84 /*
85  * Free a preparse of a user defined key payload
86  */
87 void user_free_preparse(struct key_preparsed_payload *prep)
88 {
89 	kfree(prep->payload.data[0]);
90 }
91 EXPORT_SYMBOL_GPL(user_free_preparse);
92 
93 /*
94  * update a user defined key
95  * - the key's semaphore is write-locked
96  */
97 int user_update(struct key *key, struct key_preparsed_payload *prep)
98 {
99 	struct user_key_payload *upayload, *zap;
100 	size_t datalen = prep->datalen;
101 	int ret;
102 
103 	ret = -EINVAL;
104 	if (datalen <= 0 || datalen > 32767 || !prep->data)
105 		goto error;
106 
107 	/* construct a replacement payload */
108 	ret = -ENOMEM;
109 	upayload = kmalloc(sizeof(*upayload) + datalen, GFP_KERNEL);
110 	if (!upayload)
111 		goto error;
112 
113 	upayload->datalen = datalen;
114 	memcpy(upayload->data, prep->data, datalen);
115 
116 	/* check the quota and attach the new data */
117 	zap = upayload;
118 
119 	ret = key_payload_reserve(key, datalen);
120 
121 	if (ret == 0) {
122 		/* attach the new data, displacing the old */
123 		if (!test_bit(KEY_FLAG_NEGATIVE, &key->flags))
124 			zap = key->payload.data[0];
125 		else
126 			zap = NULL;
127 		rcu_assign_keypointer(key, upayload);
128 		key->expiry = 0;
129 	}
130 
131 	if (zap)
132 		kfree_rcu(zap, rcu);
133 
134 error:
135 	return ret;
136 }
137 
138 EXPORT_SYMBOL_GPL(user_update);
139 
140 /*
141  * dispose of the links from a revoked keyring
142  * - called with the key sem write-locked
143  */
144 void user_revoke(struct key *key)
145 {
146 	struct user_key_payload *upayload = key->payload.data[0];
147 
148 	/* clear the quota */
149 	key_payload_reserve(key, 0);
150 
151 	if (upayload) {
152 		rcu_assign_keypointer(key, NULL);
153 		kfree_rcu(upayload, rcu);
154 	}
155 }
156 
157 EXPORT_SYMBOL(user_revoke);
158 
159 /*
160  * dispose of the data dangling from the corpse of a user key
161  */
162 void user_destroy(struct key *key)
163 {
164 	struct user_key_payload *upayload = key->payload.data[0];
165 
166 	kfree(upayload);
167 }
168 
169 EXPORT_SYMBOL_GPL(user_destroy);
170 
171 /*
172  * describe the user key
173  */
174 void user_describe(const struct key *key, struct seq_file *m)
175 {
176 	seq_puts(m, key->description);
177 	if (key_is_instantiated(key))
178 		seq_printf(m, ": %u", key->datalen);
179 }
180 
181 EXPORT_SYMBOL_GPL(user_describe);
182 
183 /*
184  * read the key data
185  * - the key's semaphore is read-locked
186  */
187 long user_read(const struct key *key, char __user *buffer, size_t buflen)
188 {
189 	const struct user_key_payload *upayload;
190 	long ret;
191 
192 	upayload = user_key_payload(key);
193 	ret = upayload->datalen;
194 
195 	/* we can return the data as is */
196 	if (buffer && buflen > 0) {
197 		if (buflen > upayload->datalen)
198 			buflen = upayload->datalen;
199 
200 		if (copy_to_user(buffer, upayload->data, buflen) != 0)
201 			ret = -EFAULT;
202 	}
203 
204 	return ret;
205 }
206 
207 EXPORT_SYMBOL_GPL(user_read);
208 
209 /* Vet the description for a "logon" key */
210 static int logon_vet_description(const char *desc)
211 {
212 	char *p;
213 
214 	/* require a "qualified" description string */
215 	p = strchr(desc, ':');
216 	if (!p)
217 		return -EINVAL;
218 
219 	/* also reject description with ':' as first char */
220 	if (p == desc)
221 		return -EINVAL;
222 
223 	return 0;
224 }
225