1 /* Large capacity key type
3 * Copyright (C) 2013 Red Hat, Inc. All Rights Reserved.
4 * Written by David Howells (dhowells@redhat.com)
6 * This program is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU General Public Licence
8 * as published by the Free Software Foundation; either version
9 * 2 of the Licence, or (at your option) any later version.
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>
21 MODULE_LICENSE("GPL");
24 * If the data is under this limit, there's no point creating a shm file to
25 * hold it as the permanently resident metadata for the shmem fs will be at
26 * least as large as the data.
28 #define BIG_KEY_FILE_THRESHOLD (sizeof(struct inode) + sizeof(struct dentry))
31 * big_key defined keys take an arbitrary string as the description and an
32 * arbitrary blob of data as the payload
34 struct key_type key_type_big_key
= {
36 .def_lookup_type
= KEYRING_SEARCH_LOOKUP_DIRECT
,
37 .preparse
= big_key_preparse
,
38 .free_preparse
= big_key_free_preparse
,
39 .instantiate
= generic_key_instantiate
,
41 .revoke
= big_key_revoke
,
42 .destroy
= big_key_destroy
,
43 .describe
= big_key_describe
,
50 int big_key_preparse(struct key_preparsed_payload
*prep
)
52 struct path
*path
= (struct path
*)&prep
->payload
;
55 size_t datalen
= prep
->datalen
;
59 if (datalen
<= 0 || datalen
> 1024 * 1024 || !prep
->data
)
62 /* Set an arbitrary quota */
65 prep
->type_data
[1] = (void *)(unsigned long)datalen
;
67 if (datalen
> BIG_KEY_FILE_THRESHOLD
) {
68 /* Create a shmem file to store the data in. This will permit the data
69 * to be swapped out if needed.
71 * TODO: Encrypt the stored data with a temporary key.
73 file
= shmem_kernel_file_setup("", datalen
, 0);
79 written
= kernel_write(file
, prep
->data
, prep
->datalen
, 0);
80 if (written
!= datalen
) {
87 /* Pin the mount and dentry to the key so that we can open it again
94 /* Just store the data in a buffer */
95 void *data
= kmalloc(datalen
, GFP_KERNEL
);
99 prep
->payload
[0] = memcpy(data
, prep
->data
, prep
->datalen
);
110 * Clear preparsement.
112 void big_key_free_preparse(struct key_preparsed_payload
*prep
)
114 if (prep
->datalen
> BIG_KEY_FILE_THRESHOLD
) {
115 struct path
*path
= (struct path
*)&prep
->payload
;
118 kfree(prep
->payload
[0]);
123 * dispose of the links from a revoked keyring
124 * - called with the key sem write-locked
126 void big_key_revoke(struct key
*key
)
128 struct path
*path
= (struct path
*)&key
->payload
.data2
;
130 /* clear the quota */
131 key_payload_reserve(key
, 0);
132 if (key_is_instantiated(key
) && key
->type_data
.x
[1] > BIG_KEY_FILE_THRESHOLD
)
133 vfs_truncate(path
, 0);
137 * dispose of the data dangling from the corpse of a big_key key
139 void big_key_destroy(struct key
*key
)
141 if (key
->type_data
.x
[1] > BIG_KEY_FILE_THRESHOLD
) {
142 struct path
*path
= (struct path
*)&key
->payload
.data2
;
147 kfree(key
->payload
.data
);
148 key
->payload
.data
= NULL
;
153 * describe the big_key key
155 void big_key_describe(const struct key
*key
, struct seq_file
*m
)
157 unsigned long datalen
= key
->type_data
.x
[1];
159 seq_puts(m
, key
->description
);
161 if (key_is_instantiated(key
))
162 seq_printf(m
, ": %lu [%s]",
164 datalen
> BIG_KEY_FILE_THRESHOLD
? "file" : "buff");
169 * - the key's semaphore is read-locked
171 long big_key_read(const struct key
*key
, char __user
*buffer
, size_t buflen
)
173 unsigned long datalen
= key
->type_data
.x
[1];
176 if (!buffer
|| buflen
< datalen
)
179 if (datalen
> BIG_KEY_FILE_THRESHOLD
) {
180 struct path
*path
= (struct path
*)&key
->payload
.data2
;
184 file
= dentry_open(path
, O_RDONLY
, current_cred());
186 return PTR_ERR(file
);
189 ret
= vfs_read(file
, buffer
, datalen
, &pos
);
191 if (ret
>= 0 && ret
!= datalen
)
195 if (copy_to_user(buffer
, key
->payload
.data
, datalen
) != 0)
205 static int __init
big_key_init(void)
207 return register_key_type(&key_type_big_key
);
210 static void __exit
big_key_cleanup(void)
212 unregister_key_type(&key_type_big_key
);
215 module_init(big_key_init
);
216 module_exit(big_key_cleanup
);