1
2
3
4
5
6
7
8
9
10
11
12#include <linux/module.h>
13#include <linux/init.h>
14#include <linux/seq_file.h>
15#include <linux/file.h>
16#include <linux/shmem_fs.h>
17#include <linux/err.h>
18#include <keys/user-type.h>
19#include <keys/big_key-type.h>
20
21MODULE_LICENSE("GPL");
22
23
24
25
26
27
28#define BIG_KEY_FILE_THRESHOLD (sizeof(struct inode) + sizeof(struct dentry))
29
30
31
32
33
34struct key_type key_type_big_key = {
35 .name = "big_key",
36 .preparse = big_key_preparse,
37 .free_preparse = big_key_free_preparse,
38 .instantiate = generic_key_instantiate,
39 .revoke = big_key_revoke,
40 .destroy = big_key_destroy,
41 .describe = big_key_describe,
42 .read = big_key_read,
43};
44
45
46
47
48int big_key_preparse(struct key_preparsed_payload *prep)
49{
50 struct path *path = (struct path *)&prep->payload;
51 struct file *file;
52 ssize_t written;
53 size_t datalen = prep->datalen;
54 int ret;
55
56 ret = -EINVAL;
57 if (datalen <= 0 || datalen > 1024 * 1024 || !prep->data)
58 goto error;
59
60
61 prep->quotalen = 16;
62
63 prep->type_data[1] = (void *)(unsigned long)datalen;
64
65 if (datalen > BIG_KEY_FILE_THRESHOLD) {
66
67
68
69
70
71 file = shmem_kernel_file_setup("", datalen, 0);
72 if (IS_ERR(file)) {
73 ret = PTR_ERR(file);
74 goto error;
75 }
76
77 written = kernel_write(file, prep->data, prep->datalen, 0);
78 if (written != datalen) {
79 ret = written;
80 if (written >= 0)
81 ret = -ENOMEM;
82 goto err_fput;
83 }
84
85
86
87
88 *path = file->f_path;
89 path_get(path);
90 fput(file);
91 } else {
92
93 void *data = kmalloc(datalen, GFP_KERNEL);
94 if (!data)
95 return -ENOMEM;
96
97 prep->payload[0] = memcpy(data, prep->data, prep->datalen);
98 }
99 return 0;
100
101err_fput:
102 fput(file);
103error:
104 return ret;
105}
106
107
108
109
110void big_key_free_preparse(struct key_preparsed_payload *prep)
111{
112 if (prep->datalen > BIG_KEY_FILE_THRESHOLD) {
113 struct path *path = (struct path *)&prep->payload;
114 path_put(path);
115 } else {
116 kfree(prep->payload[0]);
117 }
118}
119
120
121
122
123
124void big_key_revoke(struct key *key)
125{
126 struct path *path = (struct path *)&key->payload.data2;
127
128
129 key_payload_reserve(key, 0);
130 if (key_is_instantiated(key) && key->type_data.x[1] > BIG_KEY_FILE_THRESHOLD)
131 vfs_truncate(path, 0);
132}
133
134
135
136
137void big_key_destroy(struct key *key)
138{
139 if (key->type_data.x[1] > BIG_KEY_FILE_THRESHOLD) {
140 struct path *path = (struct path *)&key->payload.data2;
141 path_put(path);
142 path->mnt = NULL;
143 path->dentry = NULL;
144 } else {
145 kfree(key->payload.data);
146 key->payload.data = NULL;
147 }
148}
149
150
151
152
153void big_key_describe(const struct key *key, struct seq_file *m)
154{
155 unsigned long datalen = key->type_data.x[1];
156
157 seq_puts(m, key->description);
158
159 if (key_is_instantiated(key))
160 seq_printf(m, ": %lu [%s]",
161 datalen,
162 datalen > BIG_KEY_FILE_THRESHOLD ? "file" : "buff");
163}
164
165
166
167
168
169long big_key_read(const struct key *key, char __user *buffer, size_t buflen)
170{
171 unsigned long datalen = key->type_data.x[1];
172 long ret;
173
174 if (!buffer || buflen < datalen)
175 return datalen;
176
177 if (datalen > BIG_KEY_FILE_THRESHOLD) {
178 struct path *path = (struct path *)&key->payload.data2;
179 struct file *file;
180 loff_t pos;
181
182 file = dentry_open(path, O_RDONLY, current_cred());
183 if (IS_ERR(file))
184 return PTR_ERR(file);
185
186 pos = 0;
187 ret = vfs_read(file, buffer, datalen, &pos);
188 fput(file);
189 if (ret >= 0 && ret != datalen)
190 ret = -EIO;
191 } else {
192 ret = datalen;
193 if (copy_to_user(buffer, key->payload.data, datalen) != 0)
194 ret = -EFAULT;
195 }
196
197 return ret;
198}
199
200
201
202
203static int __init big_key_init(void)
204{
205 return register_key_type(&key_type_big_key);
206}
207
208static void __exit big_key_cleanup(void)
209{
210 unregister_key_type(&key_type_big_key);
211}
212
213module_init(big_key_init);
214module_exit(big_key_cleanup);
215