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 .instantiate = big_key_instantiate,
39 .revoke = big_key_revoke,
40 .destroy = big_key_destroy,
41 .describe = big_key_describe,
46 * Instantiate a big key
48 int big_key_instantiate(struct key *key, struct key_preparsed_payload *prep)
50 struct path *path = (struct path *)&key->payload.data2;
53 size_t datalen = prep->datalen;
57 if (datalen <= 0 || datalen > 1024 * 1024 || !prep->data)
60 /* Set an arbitrary quota */
61 ret = key_payload_reserve(key, 16);
65 key->type_data.x[1] = 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_file_setup("", datalen, 0);
77 written = kernel_write(file, prep->data, prep->datalen, 0);
78 if (written != datalen) {
84 /* Pin the mount and dentry to the key so that we can open it again
91 /* Just store the data in a buffer */
92 void *data = kmalloc(datalen, GFP_KERNEL);
98 key->payload.data = memcpy(data, prep->data, prep->datalen);
105 key_payload_reserve(key, 0);
111 * dispose of the links from a revoked keyring
112 * - called with the key sem write-locked
114 void big_key_revoke(struct key *key)
116 struct path *path = (struct path *)&key->payload.data2;
118 /* clear the quota */
119 key_payload_reserve(key, 0);
120 if (key_is_instantiated(key) && key->type_data.x[1] > BIG_KEY_FILE_THRESHOLD)
121 vfs_truncate(path, 0);
125 * dispose of the data dangling from the corpse of a big_key key
127 void big_key_destroy(struct key *key)
129 if (key->type_data.x[1] > BIG_KEY_FILE_THRESHOLD) {
130 struct path *path = (struct path *)&key->payload.data2;
135 kfree(key->payload.data);
136 key->payload.data = NULL;
141 * describe the big_key key
143 void big_key_describe(const struct key *key, struct seq_file *m)
145 unsigned long datalen = key->type_data.x[1];
147 seq_puts(m, key->description);
149 if (key_is_instantiated(key))
150 seq_printf(m, ": %lu [%s]",
152 datalen > BIG_KEY_FILE_THRESHOLD ? "file" : "buff");
157 * - the key's semaphore is read-locked
159 long big_key_read(const struct key *key, char __user *buffer, size_t buflen)
161 unsigned long datalen = key->type_data.x[1];
164 if (!buffer || buflen < datalen)
167 if (datalen > BIG_KEY_FILE_THRESHOLD) {
168 struct path *path = (struct path *)&key->payload.data2;
172 file = dentry_open(path, O_RDONLY, current_cred());
174 return PTR_ERR(file);
177 ret = vfs_read(file, buffer, datalen, &pos);
179 if (ret >= 0 && ret != datalen)
183 if (copy_to_user(buffer, key->payload.data, datalen) != 0)
193 static int __init big_key_init(void)
195 return register_key_type(&key_type_big_key);
198 static void __exit big_key_cleanup(void)
200 unregister_key_type(&key_type_big_key);
203 module_init(big_key_init);
204 module_exit(big_key_cleanup);