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 .instantiate = user_instantiate, 30 .update = user_update, 31 .match = user_match, 32 .revoke = user_revoke, 33 .destroy = user_destroy, 34 .describe = user_describe, 35 .read = user_read, 36 }; 37 38 EXPORT_SYMBOL_GPL(key_type_user); 39 40 /* 41 * This key type is essentially the same as key_type_user, but it does 42 * not define a .read op. This is suitable for storing username and 43 * password pairs in the keyring that you do not want to be readable 44 * from userspace. 45 */ 46 struct key_type key_type_logon = { 47 .name = "logon", 48 .instantiate = user_instantiate, 49 .update = user_update, 50 .match = user_match, 51 .revoke = user_revoke, 52 .destroy = user_destroy, 53 .describe = user_describe, 54 .vet_description = logon_vet_description, 55 }; 56 EXPORT_SYMBOL_GPL(key_type_logon); 57 58 /* 59 * instantiate a user defined key 60 */ 61 int user_instantiate(struct key *key, struct key_preparsed_payload *prep) 62 { 63 struct user_key_payload *upayload; 64 size_t datalen = prep->datalen; 65 int ret; 66 67 ret = -EINVAL; 68 if (datalen <= 0 || datalen > 32767 || !prep->data) 69 goto error; 70 71 ret = key_payload_reserve(key, datalen); 72 if (ret < 0) 73 goto error; 74 75 ret = -ENOMEM; 76 upayload = kmalloc(sizeof(*upayload) + datalen, GFP_KERNEL); 77 if (!upayload) 78 goto error; 79 80 /* attach the data */ 81 upayload->datalen = datalen; 82 memcpy(upayload->data, prep->data, datalen); 83 rcu_assign_keypointer(key, upayload); 84 ret = 0; 85 86 error: 87 return ret; 88 } 89 90 EXPORT_SYMBOL_GPL(user_instantiate); 91 92 /* 93 * update a user defined key 94 * - the key's semaphore is write-locked 95 */ 96 int user_update(struct key *key, struct key_preparsed_payload *prep) 97 { 98 struct user_key_payload *upayload, *zap; 99 size_t datalen = prep->datalen; 100 int ret; 101 102 ret = -EINVAL; 103 if (datalen <= 0 || datalen > 32767 || !prep->data) 104 goto error; 105 106 /* construct a replacement payload */ 107 ret = -ENOMEM; 108 upayload = kmalloc(sizeof(*upayload) + datalen, GFP_KERNEL); 109 if (!upayload) 110 goto error; 111 112 upayload->datalen = datalen; 113 memcpy(upayload->data, prep->data, datalen); 114 115 /* check the quota and attach the new data */ 116 zap = upayload; 117 118 ret = key_payload_reserve(key, datalen); 119 120 if (ret == 0) { 121 /* attach the new data, displacing the old */ 122 zap = key->payload.data; 123 rcu_assign_keypointer(key, upayload); 124 key->expiry = 0; 125 } 126 127 if (zap) 128 kfree_rcu(zap, rcu); 129 130 error: 131 return ret; 132 } 133 134 EXPORT_SYMBOL_GPL(user_update); 135 136 /* 137 * match users on their name 138 */ 139 int user_match(const struct key *key, const void *description) 140 { 141 return strcmp(key->description, description) == 0; 142 } 143 144 EXPORT_SYMBOL_GPL(user_match); 145 146 /* 147 * dispose of the links from a revoked keyring 148 * - called with the key sem write-locked 149 */ 150 void user_revoke(struct key *key) 151 { 152 struct user_key_payload *upayload = key->payload.data; 153 154 /* clear the quota */ 155 key_payload_reserve(key, 0); 156 157 if (upayload) { 158 rcu_assign_keypointer(key, NULL); 159 kfree_rcu(upayload, rcu); 160 } 161 } 162 163 EXPORT_SYMBOL(user_revoke); 164 165 /* 166 * dispose of the data dangling from the corpse of a user key 167 */ 168 void user_destroy(struct key *key) 169 { 170 struct user_key_payload *upayload = key->payload.data; 171 172 kfree(upayload); 173 } 174 175 EXPORT_SYMBOL_GPL(user_destroy); 176 177 /* 178 * describe the user key 179 */ 180 void user_describe(const struct key *key, struct seq_file *m) 181 { 182 seq_puts(m, key->description); 183 if (key_is_instantiated(key)) 184 seq_printf(m, ": %u", key->datalen); 185 } 186 187 EXPORT_SYMBOL_GPL(user_describe); 188 189 /* 190 * read the key data 191 * - the key's semaphore is read-locked 192 */ 193 long user_read(const struct key *key, char __user *buffer, size_t buflen) 194 { 195 struct user_key_payload *upayload; 196 long ret; 197 198 upayload = rcu_dereference_key(key); 199 ret = upayload->datalen; 200 201 /* we can return the data as is */ 202 if (buffer && buflen > 0) { 203 if (buflen > upayload->datalen) 204 buflen = upayload->datalen; 205 206 if (copy_to_user(buffer, upayload->data, buflen) != 0) 207 ret = -EFAULT; 208 } 209 210 return ret; 211 } 212 213 EXPORT_SYMBOL_GPL(user_read); 214 215 /* Vet the description for a "logon" key */ 216 static int logon_vet_description(const char *desc) 217 { 218 char *p; 219 220 /* require a "qualified" description string */ 221 p = strchr(desc, ':'); 222 if (!p) 223 return -EINVAL; 224 225 /* also reject description with ':' as first char */ 226 if (p == desc) 227 return -EINVAL; 228 229 return 0; 230 } 231