1 /* Large capacity key type 2 * 3 * Copyright (C) 2013 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 Licence 8 * as published by the Free Software Foundation; either version 9 * 2 of the Licence, or (at your option) any later version. 10 */ 11 12 #include <linux/init.h> 13 #include <linux/seq_file.h> 14 #include <linux/file.h> 15 #include <linux/shmem_fs.h> 16 #include <linux/err.h> 17 #include <keys/user-type.h> 18 #include <keys/big_key-type.h> 19 20 /* 21 * Layout of key payload words. 22 */ 23 enum { 24 big_key_data, 25 big_key_path, 26 big_key_path_2nd_part, 27 big_key_len, 28 }; 29 30 /* 31 * If the data is under this limit, there's no point creating a shm file to 32 * hold it as the permanently resident metadata for the shmem fs will be at 33 * least as large as the data. 34 */ 35 #define BIG_KEY_FILE_THRESHOLD (sizeof(struct inode) + sizeof(struct dentry)) 36 37 /* 38 * big_key defined keys take an arbitrary string as the description and an 39 * arbitrary blob of data as the payload 40 */ 41 struct key_type key_type_big_key = { 42 .name = "big_key", 43 .preparse = big_key_preparse, 44 .free_preparse = big_key_free_preparse, 45 .instantiate = generic_key_instantiate, 46 .revoke = big_key_revoke, 47 .destroy = big_key_destroy, 48 .describe = big_key_describe, 49 .read = big_key_read, 50 }; 51 52 /* 53 * Preparse a big key 54 */ 55 int big_key_preparse(struct key_preparsed_payload *prep) 56 { 57 struct path *path = (struct path *)&prep->payload.data[big_key_path]; 58 struct file *file; 59 ssize_t written; 60 size_t datalen = prep->datalen; 61 int ret; 62 63 ret = -EINVAL; 64 if (datalen <= 0 || datalen > 1024 * 1024 || !prep->data) 65 goto error; 66 67 /* Set an arbitrary quota */ 68 prep->quotalen = 16; 69 70 prep->payload.data[big_key_len] = (void *)(unsigned long)datalen; 71 72 if (datalen > BIG_KEY_FILE_THRESHOLD) { 73 /* Create a shmem file to store the data in. This will permit the data 74 * to be swapped out if needed. 75 * 76 * TODO: Encrypt the stored data with a temporary key. 77 */ 78 file = shmem_kernel_file_setup("", datalen, 0); 79 if (IS_ERR(file)) { 80 ret = PTR_ERR(file); 81 goto error; 82 } 83 84 written = kernel_write(file, prep->data, prep->datalen, 0); 85 if (written != datalen) { 86 ret = written; 87 if (written >= 0) 88 ret = -ENOMEM; 89 goto err_fput; 90 } 91 92 /* Pin the mount and dentry to the key so that we can open it again 93 * later 94 */ 95 *path = file->f_path; 96 path_get(path); 97 fput(file); 98 } else { 99 /* Just store the data in a buffer */ 100 void *data = kmalloc(datalen, GFP_KERNEL); 101 if (!data) 102 return -ENOMEM; 103 104 prep->payload.data[big_key_data] = data; 105 memcpy(data, prep->data, prep->datalen); 106 } 107 return 0; 108 109 err_fput: 110 fput(file); 111 error: 112 return ret; 113 } 114 115 /* 116 * Clear preparsement. 117 */ 118 void big_key_free_preparse(struct key_preparsed_payload *prep) 119 { 120 if (prep->datalen > BIG_KEY_FILE_THRESHOLD) { 121 struct path *path = (struct path *)&prep->payload.data[big_key_path]; 122 path_put(path); 123 } else { 124 kfree(prep->payload.data[big_key_data]); 125 } 126 } 127 128 /* 129 * dispose of the links from a revoked keyring 130 * - called with the key sem write-locked 131 */ 132 void big_key_revoke(struct key *key) 133 { 134 struct path *path = (struct path *)&key->payload.data[big_key_path]; 135 136 /* clear the quota */ 137 key_payload_reserve(key, 0); 138 if (key_is_instantiated(key) && 139 (size_t)key->payload.data[big_key_len] > BIG_KEY_FILE_THRESHOLD) 140 vfs_truncate(path, 0); 141 } 142 143 /* 144 * dispose of the data dangling from the corpse of a big_key key 145 */ 146 void big_key_destroy(struct key *key) 147 { 148 size_t datalen = (size_t)key->payload.data[big_key_len]; 149 150 if (datalen) { 151 struct path *path = (struct path *)&key->payload.data[big_key_path]; 152 path_put(path); 153 path->mnt = NULL; 154 path->dentry = NULL; 155 } else { 156 kfree(key->payload.data[big_key_data]); 157 key->payload.data[big_key_data] = NULL; 158 } 159 } 160 161 /* 162 * describe the big_key key 163 */ 164 void big_key_describe(const struct key *key, struct seq_file *m) 165 { 166 size_t datalen = (size_t)key->payload.data[big_key_len]; 167 168 seq_puts(m, key->description); 169 170 if (key_is_instantiated(key)) 171 seq_printf(m, ": %zu [%s]", 172 datalen, 173 datalen > BIG_KEY_FILE_THRESHOLD ? "file" : "buff"); 174 } 175 176 /* 177 * read the key data 178 * - the key's semaphore is read-locked 179 */ 180 long big_key_read(const struct key *key, char __user *buffer, size_t buflen) 181 { 182 size_t datalen = (size_t)key->payload.data[big_key_len]; 183 long ret; 184 185 if (!buffer || buflen < datalen) 186 return datalen; 187 188 if (datalen > BIG_KEY_FILE_THRESHOLD) { 189 struct path *path = (struct path *)&key->payload.data[big_key_path]; 190 struct file *file; 191 loff_t pos; 192 193 file = dentry_open(path, O_RDONLY, current_cred()); 194 if (IS_ERR(file)) 195 return PTR_ERR(file); 196 197 pos = 0; 198 ret = vfs_read(file, buffer, datalen, &pos); 199 fput(file); 200 if (ret >= 0 && ret != datalen) 201 ret = -EIO; 202 } else { 203 ret = datalen; 204 if (copy_to_user(buffer, key->payload.data[big_key_data], 205 datalen) != 0) 206 ret = -EFAULT; 207 } 208 209 return ret; 210 } 211 212 static int __init big_key_init(void) 213 { 214 return register_key_type(&key_type_big_key); 215 } 216 device_initcall(big_key_init); 217