1 /* Request key authorisation token key definition. 2 * 3 * Copyright (C) 2005 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 * See Documentation/security/keys/request-key.rst 12 */ 13 14 #include <linux/sched.h> 15 #include <linux/err.h> 16 #include <linux/seq_file.h> 17 #include <linux/slab.h> 18 #include <linux/uaccess.h> 19 #include "internal.h" 20 #include <keys/user-type.h> 21 22 static int request_key_auth_preparse(struct key_preparsed_payload *); 23 static void request_key_auth_free_preparse(struct key_preparsed_payload *); 24 static int request_key_auth_instantiate(struct key *, 25 struct key_preparsed_payload *); 26 static void request_key_auth_describe(const struct key *, struct seq_file *); 27 static void request_key_auth_revoke(struct key *); 28 static void request_key_auth_destroy(struct key *); 29 static long request_key_auth_read(const struct key *, char __user *, size_t); 30 31 /* 32 * The request-key authorisation key type definition. 33 */ 34 struct key_type key_type_request_key_auth = { 35 .name = ".request_key_auth", 36 .def_datalen = sizeof(struct request_key_auth), 37 .preparse = request_key_auth_preparse, 38 .free_preparse = request_key_auth_free_preparse, 39 .instantiate = request_key_auth_instantiate, 40 .describe = request_key_auth_describe, 41 .revoke = request_key_auth_revoke, 42 .destroy = request_key_auth_destroy, 43 .read = request_key_auth_read, 44 }; 45 46 static int request_key_auth_preparse(struct key_preparsed_payload *prep) 47 { 48 return 0; 49 } 50 51 static void request_key_auth_free_preparse(struct key_preparsed_payload *prep) 52 { 53 } 54 55 /* 56 * Instantiate a request-key authorisation key. 57 */ 58 static int request_key_auth_instantiate(struct key *key, 59 struct key_preparsed_payload *prep) 60 { 61 key->payload.data[0] = (struct request_key_auth *)prep->data; 62 return 0; 63 } 64 65 /* 66 * Describe an authorisation token. 67 */ 68 static void request_key_auth_describe(const struct key *key, 69 struct seq_file *m) 70 { 71 struct request_key_auth *rka = key->payload.data[0]; 72 73 seq_puts(m, "key:"); 74 seq_puts(m, key->description); 75 if (key_is_positive(key)) 76 seq_printf(m, " pid:%d ci:%zu", rka->pid, rka->callout_len); 77 } 78 79 /* 80 * Read the callout_info data (retrieves the callout information). 81 * - the key's semaphore is read-locked 82 */ 83 static long request_key_auth_read(const struct key *key, 84 char __user *buffer, size_t buflen) 85 { 86 struct request_key_auth *rka = key->payload.data[0]; 87 size_t datalen; 88 long ret; 89 90 datalen = rka->callout_len; 91 ret = datalen; 92 93 /* we can return the data as is */ 94 if (buffer && buflen > 0) { 95 if (buflen > datalen) 96 buflen = datalen; 97 98 if (copy_to_user(buffer, rka->callout_info, buflen) != 0) 99 ret = -EFAULT; 100 } 101 102 return ret; 103 } 104 105 /* 106 * Handle revocation of an authorisation token key. 107 * 108 * Called with the key sem write-locked. 109 */ 110 static void request_key_auth_revoke(struct key *key) 111 { 112 struct request_key_auth *rka = key->payload.data[0]; 113 114 kenter("{%d}", key->serial); 115 116 if (rka->cred) { 117 put_cred(rka->cred); 118 rka->cred = NULL; 119 } 120 } 121 122 static void free_request_key_auth(struct request_key_auth *rka) 123 { 124 if (!rka) 125 return; 126 key_put(rka->target_key); 127 key_put(rka->dest_keyring); 128 if (rka->cred) 129 put_cred(rka->cred); 130 kfree(rka->callout_info); 131 kfree(rka); 132 } 133 134 /* 135 * Destroy an instantiation authorisation token key. 136 */ 137 static void request_key_auth_destroy(struct key *key) 138 { 139 struct request_key_auth *rka = key->payload.data[0]; 140 141 kenter("{%d}", key->serial); 142 143 free_request_key_auth(rka); 144 } 145 146 /* 147 * Create an authorisation token for /sbin/request-key or whoever to gain 148 * access to the caller's security data. 149 */ 150 struct key *request_key_auth_new(struct key *target, const void *callout_info, 151 size_t callout_len, struct key *dest_keyring) 152 { 153 struct request_key_auth *rka, *irka; 154 const struct cred *cred = current->cred; 155 struct key *authkey = NULL; 156 char desc[20]; 157 int ret = -ENOMEM; 158 159 kenter("%d,", target->serial); 160 161 /* allocate a auth record */ 162 rka = kzalloc(sizeof(*rka), GFP_KERNEL); 163 if (!rka) 164 goto error; 165 rka->callout_info = kmemdup(callout_info, callout_len, GFP_KERNEL); 166 if (!rka->callout_info) 167 goto error_free_rka; 168 rka->callout_len = callout_len; 169 170 /* see if the calling process is already servicing the key request of 171 * another process */ 172 if (cred->request_key_auth) { 173 /* it is - use that instantiation context here too */ 174 down_read(&cred->request_key_auth->sem); 175 176 /* if the auth key has been revoked, then the key we're 177 * servicing is already instantiated */ 178 if (test_bit(KEY_FLAG_REVOKED, 179 &cred->request_key_auth->flags)) { 180 up_read(&cred->request_key_auth->sem); 181 ret = -EKEYREVOKED; 182 goto error_free_rka; 183 } 184 185 irka = cred->request_key_auth->payload.data[0]; 186 rka->cred = get_cred(irka->cred); 187 rka->pid = irka->pid; 188 189 up_read(&cred->request_key_auth->sem); 190 } 191 else { 192 /* it isn't - use this process as the context */ 193 rka->cred = get_cred(cred); 194 rka->pid = current->pid; 195 } 196 197 rka->target_key = key_get(target); 198 rka->dest_keyring = key_get(dest_keyring); 199 200 /* allocate the auth key */ 201 sprintf(desc, "%x", target->serial); 202 203 authkey = key_alloc(&key_type_request_key_auth, desc, 204 cred->fsuid, cred->fsgid, cred, 205 KEY_POS_VIEW | KEY_POS_READ | KEY_POS_SEARCH | 206 KEY_USR_VIEW, KEY_ALLOC_NOT_IN_QUOTA, NULL); 207 if (IS_ERR(authkey)) { 208 ret = PTR_ERR(authkey); 209 goto error_free_rka; 210 } 211 212 /* construct the auth key */ 213 ret = key_instantiate_and_link(authkey, rka, 0, NULL, NULL); 214 if (ret < 0) 215 goto error_put_authkey; 216 217 kleave(" = {%d,%d}", authkey->serial, refcount_read(&authkey->usage)); 218 return authkey; 219 220 error_put_authkey: 221 key_put(authkey); 222 error_free_rka: 223 free_request_key_auth(rka); 224 error: 225 kleave("= %d", ret); 226 return ERR_PTR(ret); 227 } 228 229 /* 230 * Search the current process's keyrings for the authorisation key for 231 * instantiation of a key. 232 */ 233 struct key *key_get_instantiation_authkey(key_serial_t target_id) 234 { 235 char description[16]; 236 struct keyring_search_context ctx = { 237 .index_key.type = &key_type_request_key_auth, 238 .index_key.description = description, 239 .cred = current_cred(), 240 .match_data.cmp = key_default_cmp, 241 .match_data.raw_data = description, 242 .match_data.lookup_type = KEYRING_SEARCH_LOOKUP_DIRECT, 243 .flags = KEYRING_SEARCH_DO_STATE_CHECK, 244 }; 245 struct key *authkey; 246 key_ref_t authkey_ref; 247 248 sprintf(description, "%x", target_id); 249 250 authkey_ref = search_process_keyrings(&ctx); 251 252 if (IS_ERR(authkey_ref)) { 253 authkey = ERR_CAST(authkey_ref); 254 if (authkey == ERR_PTR(-EAGAIN)) 255 authkey = ERR_PTR(-ENOKEY); 256 goto error; 257 } 258 259 authkey = key_ref_to_ptr(authkey_ref); 260 if (test_bit(KEY_FLAG_REVOKED, &authkey->flags)) { 261 key_put(authkey); 262 authkey = ERR_PTR(-EKEYREVOKED); 263 } 264 265 error: 266 return authkey; 267 } 268