/* key.c: basic authentication token and access key management * * Copyright (C) 2004-6 Red Hat, Inc. All Rights Reserved. * Written by David Howells (dhowells@redhat.com) * * This program is free software; you can redistribute it and/or * modify it under the terms of the GNU General Public License * as published by the Free Software Foundation; either version * 2 of the License, or (at your option) any later version. */ #include <linux/module.h>#include <linux/init.h>#include <linux/sched.h>#include <linux/slab.h>#include <linux/security.h>#include <linux/workqueue.h>#include <linux/err.h>#include "internal.h" static kmem_cache_t *key_jar;static key_serial_t key_serial_next = 3;struct rb_root key_serial_tree; /* tree of keys indexed by serial */DEFINE_SPINLOCK(key_serial_lock); struct rb_root key_user_tree; /* tree of quota records indexed by UID */DEFINE_SPINLOCK(key_user_lock); static LIST_HEAD(key_types_list);static DECLARE_RWSEM(key_types_sem); static void key_cleanup(void *data);static DECLARE_WORK(key_cleanup_task, key_cleanup, NULL); /* we serialise key instantiation and link */DECLARE_RWSEM(key_construction_sem); /* any key who's type gets unegistered will be re-typed to this */static struct key_type key_type_dead = { .name = "dead",}; #ifdef KEY_DEBUGGINGvoid __key_check(const struct key *key){ printk("__key_check: key %p {%08x} should be {%08x}\n", key, key->magic, KEY_DEBUG_MAGIC); BUG();}#endif /*****************************************************************************//* * get the key quota record for a user, allocating a new record if one doesn't * already exist */struct key_user *key_user_lookup(uid_t uid){ struct key_user *candidate = NULL, *user; struct rb_node *parent = NULL; struct rb_node **p; try_again: p = &key_user_tree.rb_node; spin_lock(&key_user_lock); /* search the tree for a user record with a matching UID */ while (*p) { parent = *p; user = rb_entry(parent, struct key_user, node); if (uid < user->uid) p = &(*p)->rb_left; else if (uid > user->uid) p = &(*p)->rb_right; else goto found; } /* if we get here, we failed to find a match in the tree */ if (!candidate) { /* allocate a candidate user record if we don't already have * one */ spin_unlock(&key_user_lock); user = NULL; candidate = kmalloc(sizeof(struct key_user), GFP_KERNEL); if (unlikely(!candidate)) goto out; /* the allocation may have scheduled, so we need to repeat the * search lest someone else added the record whilst we were * asleep */ goto try_again; } /* if we get here, then the user record still hadn't appeared on the * second pass - so we use the candidate record */ atomic_set(&candidate->usage, 1); atomic_set(&candidate->nkeys, 0); atomic_set(&candidate->nikeys, 0); candidate->uid = uid; candidate->qnkeys = 0; candidate->qnbytes = 0; spin_lock_init(&candidate->lock); INIT_LIST_HEAD(&candidate->consq); rb_link_node(&candidate->node, parent, p); rb_insert_color(&candidate->node, &key_user_tree); spin_unlock(&key_user_lock); user = candidate; goto out; /* okay - we found a user record for this UID */ found: atomic_inc(&user->usage); spin_unlock(&key_user_lock); kfree(candidate); out: return user; } /* end key_user_lookup() */ /*****************************************************************************//* * dispose of a user structure */void key_user_put(struct key_user *user){ if (atomic_dec_and_lock(&user->usage, &key_user_lock)) { rb_erase(&user->node, &key_user_tree); spin_unlock(&key_user_lock); kfree(user); } } /* end key_user_put() */ /*****************************************************************************//* * insert a key with a fixed serial number */static void __init __key_insert_serial(struct key *key){ struct rb_node *parent, **p; struct key *xkey; parent = NULL; p = &key_serial_tree.rb_node; while (*p) { parent = *p; xkey = rb_entry(parent, struct key, serial_node); if (key->serial < xkey->serial) p = &(*p)->rb_left; else if (key->serial > xkey->serial) p = &(*p)->rb_right; else BUG(); } /* we've found a suitable hole - arrange for this key to occupy it */ rb_link_node(&key->serial_node, parent, p); rb_insert_color(&key->serial_node, &key_serial_tree); } /* end __key_insert_serial() */ /*****************************************************************************//* * assign a key the next unique serial number * - we work through all the serial numbers between 2 and 2^31-1 in turn and * then wrap */static inline void key_alloc_serial(struct key *key){ struct rb_node *parent, **p; struct key *xkey; spin_lock(&key_serial_lock); /* propose a likely serial number and look for a hole for it in the * serial number tree */ key->serial = key_serial_next; if (key->serial < 3) key->serial = 3; key_serial_next = key->serial + 1; parent = NULL; p = &key_serial_tree.rb_node; while (*p) { parent = *p; xkey = rb_entry(parent, struct key, serial_node); if (key->serial < xkey->serial) p = &(*p)->rb_left; else if (key->serial > xkey->serial) p = &(*p)->rb_right; else goto serial_exists; } goto insert_here; /* we found a key with the proposed serial number - walk the tree from * that point looking for the next unused serial number */ serial_exists: for (;;) { key->serial = key_serial_next; if (key->serial < 2) key->serial = 2; key_serial_next = key->serial + 1; if (!rb_parent(parent)) p = &key_serial_tree.rb_node; else if (rb_parent(parent)->rb_left == parent) p = &(rb_parent(parent)->rb_left); else p = &(rb_parent(parent)->rb_right); parent = rb_next(parent); if (!parent) break; xkey = rb_entry(parent, struct key, serial_node); if (key->serial < xkey->serial) goto insert_here; } /* we've found a suitable hole - arrange for this key to occupy it */ insert_here: rb_link_node(&key->serial_node, parent, p); rb_insert_color(&key->serial_node, &key_serial_tree); spin_unlock(&key_serial_lock); } /* end key_alloc_serial() */ /*****************************************************************************//* * allocate a key of the specified type * - update the user's quota to reflect the existence of the key * - called from a key-type operation with key_types_sem read-locked by * key_create_or_update() * - this prevents unregistration of the key type * - upon return the key is as yet uninstantiated; the caller needs to either * instantiate the key or discard it before returning */struct key *key_alloc(struct key_type *type, const char *desc, uid_t uid, gid_t gid, struct task_struct *ctx, key_perm_t perm, int not_in_quota){ struct key_user *user = NULL; struct key *key; size_t desclen, quotalen; int ret; key = ERR_PTR(-EINVAL); if (!desc || !*desc) goto error; desclen = strlen(desc) + 1; quotalen = desclen + type->def_datalen; /* get hold of the key tracking for this user */ user = key_user_lookup(uid); if (!user) goto no_memory_1; /* check that the user's quota permits allocation of another key and * its description */ if (!not_in_quota) { spin_lock(&user->lock); if (user->qnkeys + 1 >= KEYQUOTA_MAX_KEYS || user->qnbytes + quotalen >= KEYQUOTA_MAX_BYTES ) goto no_quota; user->qnkeys++; user->qnbytes += quotalen; spin_unlock(&user->lock); } /* allocate and initialise the key and its description */ key = kmem_cache_alloc(key_jar, SLAB_KERNEL); if (!key) goto no_memory_2; if (desc) { key->description = kmalloc(desclen, GFP_KERNEL); if (!key->description) goto no_memory_3; memcpy(key->description, desc, desclen); } atomic_set(&key->usage, 1); init_rwsem(&key->sem); key->type = type; key->user = user; key->quotalen = quotalen; key->datalen = type->def_datalen; key->uid = uid; key->gid = gid; key->perm = perm; key->flags = 0; key->expiry = 0; key->payload.data = NULL; key->security = NULL; if (!not_in_quota) key->flags |= 1 << KEY_FLAG_IN_QUOTA; memset(&key->type_data, 0, sizeof(key->type_data)); #ifdef KEY_DEBUGGING key->magic = KEY_DEBUG_MAGIC;#endif /* let the security module know about the key */ ret = security_key_alloc(key, ctx); if (ret < 0) goto security_error; /* publish the key by giving it a serial number */ atomic_inc(&user->nkeys); key_alloc_serial(key); error: return key; security_error: kfree(key->description); kmem_cache_free(key_jar, key); if (!not_in_quota) { spin_lock(&user->lock); user->qnkeys--; user->qnbytes -= quotalen; spin_unlock(&user->lock); } key_user_put(user); key = ERR_PTR(ret); goto error; no_memory_3: kmem_cache_free(key_jar, key);no_memory_2: if (!not_in_quota) { spin_lock(&user->lock); user->qnkeys--; user->qnbytes -= quotalen; spin_unlock(&user->lock); } key_user_put(user);no_memory_1: key = ERR_PTR(-ENOMEM); goto error; no_quota: spin_unlock(&user->lock); key_user_put(user); key = ERR_PTR(-EDQUOT); goto error; } /* end key_alloc() */ EXPORT_SYMBOL(key_alloc); /*****************************************************************************//* * reserve an amount of quota for the key's payload */int key_payload_reserve(struct key *key, size_t datalen){ int delta = (int) datalen - key->datalen; int ret = 0; key_check(key); /* contemplate the quota adjustment */ if (delta != 0 && test_bit(KEY_FLAG_IN_QUOTA, &key->flags)) { spin_lock(&key->user->lock); if (delta > 0 && key->user->qnbytes + delta > KEYQUOTA_MAX_BYTES ) { ret = -EDQUOT; } else { key->user->qnbytes += delta; key->quotalen += delta; } spin_unlock(&key->user->lock); } /* change the recorded data length if that didn't generate an error */ if (ret == 0) key->datalen = datalen; return ret; } /* end key_payload_reserve() */ EXPORT_SYMBOL(key_payload_reserve); /*****************************************************************************//* * instantiate a key and link it into the target keyring atomically * - called with the target keyring's semaphore writelocked */static int __key_instantiate_and_link(struct key *key, const void *data, size_t datalen, struct key *keyring, struct key *instkey){ int ret, awaken; key_check(key); key_check(keyring); awaken = 0; ret = -EBUSY; down_write(&key_construction_sem); /* can't instantiate twice */ if (!test_bit(KEY_FLAG_INSTANTIATED, &key->flags)) { /* instantiate the key */ ret = key->type->instantiate(key, data, datalen); if (ret == 0) { /* mark the key as being instantiated */ atomic_inc(&key->user->nikeys); set_bit(KEY_FLAG_INSTANTIATED, &key->flags); if (test_and_clear_bit(KEY_FLAG_USER_CONSTRUCT, &key->flags)) awaken = 1; /* and link it into the destination keyring */ if (keyring) ret = __key_link(keyring, key); /* disable the authorisation key */ if (instkey) key_revoke(instkey); } } up_write(&key_construction_sem); /* wake up anyone waiting for a key to be constructed */ if (awaken) wake_up_all(&request_key_conswq); return ret; } /* end __key_instantiate_and_link() */ /*****************************************************************************//* * instantiate a key and link it into the target keyring atomically */int key_instantiate_and_link(struct key *key, const void *data, size_t datalen, struct key *keyring, struct key *instkey){ int ret; if (keyring) down_write(&keyring->sem); ret = __key_instantiate_and_link(key, data, datalen, keyring, instkey); if (keyring) up_write(&keyring->sem); return ret; } /* end key_instantiate_and_link() */ EXPORT_SYMBOL(key_instantiate_and_link); /*****************************************************************************//* * negatively instantiate a key and link it into the target keyring atomically */int key_negate_and_link(struct key *key, unsigned timeout, struct key *keyring, struct key *instkey){ struct timespec now; int ret, awaken; key_check(key); key_check(keyring); Lines 1–500 of 1032. Load more
/* key.c: basic authentication token and access key management * * Copyright (C) 2004-6 Red Hat, Inc. All Rights Reserved. * Written by David Howells (dhowells@redhat.com) * * This program is free software; you can redistribute it and/or * modify it under the terms of the GNU General Public License * as published by the Free Software Foundation; either version * 2 of the License, or (at your option) any later version. */ #include <linux/module.h> #include <linux/init.h> #include <linux/sched.h> #include <linux/slab.h> #include <linux/security.h> #include <linux/workqueue.h> #include <linux/err.h> #include "internal.h" static kmem_cache_t *key_jar; static key_serial_t key_serial_next = 3; struct rb_root key_serial_tree; /* tree of keys indexed by serial */ DEFINE_SPINLOCK(key_serial_lock); struct rb_root key_user_tree; /* tree of quota records indexed by UID */ DEFINE_SPINLOCK(key_user_lock); static LIST_HEAD(key_types_list); static DECLARE_RWSEM(key_types_sem); static void key_cleanup(void *data); static DECLARE_WORK(key_cleanup_task, key_cleanup, NULL); /* we serialise key instantiation and link */ DECLARE_RWSEM(key_construction_sem); /* any key who's type gets unegistered will be re-typed to this */ static struct key_type key_type_dead = { .name = "dead", }; #ifdef KEY_DEBUGGING void __key_check(const struct key *key) { printk("__key_check: key %p {%08x} should be {%08x}\n", key, key->magic, KEY_DEBUG_MAGIC); BUG(); } #endif /*****************************************************************************/ /* * get the key quota record for a user, allocating a new record if one doesn't * already exist */ struct key_user *key_user_lookup(uid_t uid) { struct key_user *candidate = NULL, *user; struct rb_node *parent = NULL; struct rb_node **p; try_again: p = &key_user_tree.rb_node; spin_lock(&key_user_lock); /* search the tree for a user record with a matching UID */ while (*p) { parent = *p; user = rb_entry(parent, struct key_user, node); if (uid < user->uid) p = &(*p)->rb_left; else if (uid > user->uid) p = &(*p)->rb_right; else goto found; } /* if we get here, we failed to find a match in the tree */ if (!candidate) { /* allocate a candidate user record if we don't already have * one */ spin_unlock(&key_user_lock); user = NULL; candidate = kmalloc(sizeof(struct key_user), GFP_KERNEL); if (unlikely(!candidate)) goto out; /* the allocation may have scheduled, so we need to repeat the * search lest someone else added the record whilst we were * asleep */ goto try_again; } /* if we get here, then the user record still hadn't appeared on the * second pass - so we use the candidate record */ atomic_set(&candidate->usage, 1); atomic_set(&candidate->nkeys, 0); atomic_set(&candidate->nikeys, 0); candidate->uid = uid; candidate->qnkeys = 0; candidate->qnbytes = 0; spin_lock_init(&candidate->lock); INIT_LIST_HEAD(&candidate->consq); rb_link_node(&candidate->node, parent, p); rb_insert_color(&candidate->node, &key_user_tree); spin_unlock(&key_user_lock); user = candidate; goto out; /* okay - we found a user record for this UID */ found: atomic_inc(&user->usage); spin_unlock(&key_user_lock); kfree(candidate); out: return user; } /* end key_user_lookup() */ /*****************************************************************************/ /* * dispose of a user structure */ void key_user_put(struct key_user *user) { if (atomic_dec_and_lock(&user->usage, &key_user_lock)) { rb_erase(&user->node, &key_user_tree); spin_unlock(&key_user_lock); kfree(user); } } /* end key_user_put() */ /*****************************************************************************/ /* * insert a key with a fixed serial number */ static void __init __key_insert_serial(struct key *key) { struct rb_node *parent, **p; struct key *xkey; parent = NULL; p = &key_serial_tree.rb_node; while (*p) { parent = *p; xkey = rb_entry(parent, struct key, serial_node); if (key->serial < xkey->serial) p = &(*p)->rb_left; else if (key->serial > xkey->serial) p = &(*p)->rb_right; else BUG(); } /* we've found a suitable hole - arrange for this key to occupy it */ rb_link_node(&key->serial_node, parent, p); rb_insert_color(&key->serial_node, &key_serial_tree); } /* end __key_insert_serial() */ /*****************************************************************************/ /* * assign a key the next unique serial number * - we work through all the serial numbers between 2 and 2^31-1 in turn and * then wrap */ static inline void key_alloc_serial(struct key *key) { struct rb_node *parent, **p; struct key *xkey; spin_lock(&key_serial_lock); /* propose a likely serial number and look for a hole for it in the * serial number tree */ key->serial = key_serial_next; if (key->serial < 3) key->serial = 3; key_serial_next = key->serial + 1; parent = NULL; p = &key_serial_tree.rb_node; while (*p) { parent = *p; xkey = rb_entry(parent, struct key, serial_node); if (key->serial < xkey->serial) p = &(*p)->rb_left; else if (key->serial > xkey->serial) p = &(*p)->rb_right; else goto serial_exists; } goto insert_here; /* we found a key with the proposed serial number - walk the tree from * that point looking for the next unused serial number */ serial_exists: for (;;) { key->serial = key_serial_next; if (key->serial < 2) key->serial = 2; key_serial_next = key->serial + 1; if (!rb_parent(parent)) p = &key_serial_tree.rb_node; else if (rb_parent(parent)->rb_left == parent) p = &(rb_parent(parent)->rb_left); else p = &(rb_parent(parent)->rb_right); parent = rb_next(parent); if (!parent) break; xkey = rb_entry(parent, struct key, serial_node); if (key->serial < xkey->serial) goto insert_here; } /* we've found a suitable hole - arrange for this key to occupy it */ insert_here: rb_link_node(&key->serial_node, parent, p); rb_insert_color(&key->serial_node, &key_serial_tree); spin_unlock(&key_serial_lock); } /* end key_alloc_serial() */ /*****************************************************************************/ /* * allocate a key of the specified type * - update the user's quota to reflect the existence of the key * - called from a key-type operation with key_types_sem read-locked by * key_create_or_update() * - this prevents unregistration of the key type * - upon return the key is as yet uninstantiated; the caller needs to either * instantiate the key or discard it before returning */ struct key *key_alloc(struct key_type *type, const char *desc, uid_t uid, gid_t gid, struct task_struct *ctx, key_perm_t perm, int not_in_quota) { struct key_user *user = NULL; struct key *key; size_t desclen, quotalen; int ret; key = ERR_PTR(-EINVAL); if (!desc || !*desc) goto error; desclen = strlen(desc) + 1; quotalen = desclen + type->def_datalen; /* get hold of the key tracking for this user */ user = key_user_lookup(uid); if (!user) goto no_memory_1; /* check that the user's quota permits allocation of another key and * its description */ if (!not_in_quota) { spin_lock(&user->lock); if (user->qnkeys + 1 >= KEYQUOTA_MAX_KEYS || user->qnbytes + quotalen >= KEYQUOTA_MAX_BYTES ) goto no_quota; user->qnkeys++; user->qnbytes += quotalen; spin_unlock(&user->lock); } /* allocate and initialise the key and its description */ key = kmem_cache_alloc(key_jar, SLAB_KERNEL); if (!key) goto no_memory_2; if (desc) { key->description = kmalloc(desclen, GFP_KERNEL); if (!key->description) goto no_memory_3; memcpy(key->description, desc, desclen); } atomic_set(&key->usage, 1); init_rwsem(&key->sem); key->type = type; key->user = user; key->quotalen = quotalen; key->datalen = type->def_datalen; key->uid = uid; key->gid = gid; key->perm = perm; key->flags = 0; key->expiry = 0; key->payload.data = NULL; key->security = NULL; if (!not_in_quota) key->flags |= 1 << KEY_FLAG_IN_QUOTA; memset(&key->type_data, 0, sizeof(key->type_data)); #ifdef KEY_DEBUGGING key->magic = KEY_DEBUG_MAGIC; #endif /* let the security module know about the key */ ret = security_key_alloc(key, ctx); if (ret < 0) goto security_error; /* publish the key by giving it a serial number */ atomic_inc(&user->nkeys); key_alloc_serial(key); error: return key; security_error: kfree(key->description); kmem_cache_free(key_jar, key); if (!not_in_quota) { spin_lock(&user->lock); user->qnkeys--; user->qnbytes -= quotalen; spin_unlock(&user->lock); } key_user_put(user); key = ERR_PTR(ret); goto error; no_memory_3: kmem_cache_free(key_jar, key); no_memory_2: if (!not_in_quota) { spin_lock(&user->lock); user->qnkeys--; user->qnbytes -= quotalen; spin_unlock(&user->lock); } key_user_put(user); no_memory_1: key = ERR_PTR(-ENOMEM); goto error; no_quota: spin_unlock(&user->lock); key_user_put(user); key = ERR_PTR(-EDQUOT); goto error; } /* end key_alloc() */ EXPORT_SYMBOL(key_alloc); /*****************************************************************************/ /* * reserve an amount of quota for the key's payload */ int key_payload_reserve(struct key *key, size_t datalen) { int delta = (int) datalen - key->datalen; int ret = 0; key_check(key); /* contemplate the quota adjustment */ if (delta != 0 && test_bit(KEY_FLAG_IN_QUOTA, &key->flags)) { spin_lock(&key->user->lock); if (delta > 0 && key->user->qnbytes + delta > KEYQUOTA_MAX_BYTES ) { ret = -EDQUOT; } else { key->user->qnbytes += delta; key->quotalen += delta; } spin_unlock(&key->user->lock); } /* change the recorded data length if that didn't generate an error */ if (ret == 0) key->datalen = datalen; return ret; } /* end key_payload_reserve() */ EXPORT_SYMBOL(key_payload_reserve); /*****************************************************************************/ /* * instantiate a key and link it into the target keyring atomically * - called with the target keyring's semaphore writelocked */ static int __key_instantiate_and_link(struct key *key, const void *data, size_t datalen, struct key *keyring, struct key *instkey) { int ret, awaken; key_check(key); key_check(keyring); awaken = 0; ret = -EBUSY; down_write(&key_construction_sem); /* can't instantiate twice */ if (!test_bit(KEY_FLAG_INSTANTIATED, &key->flags)) { /* instantiate the key */ ret = key->type->instantiate(key, data, datalen); if (ret == 0) { /* mark the key as being instantiated */ atomic_inc(&key->user->nikeys); set_bit(KEY_FLAG_INSTANTIATED, &key->flags); if (test_and_clear_bit(KEY_FLAG_USER_CONSTRUCT, &key->flags)) awaken = 1; /* and link it into the destination keyring */ if (keyring) ret = __key_link(keyring, key); /* disable the authorisation key */ if (instkey) key_revoke(instkey); } } up_write(&key_construction_sem); /* wake up anyone waiting for a key to be constructed */ if (awaken) wake_up_all(&request_key_conswq); return ret; } /* end __key_instantiate_and_link() */ /*****************************************************************************/ /* * instantiate a key and link it into the target keyring atomically */ int key_instantiate_and_link(struct key *key, const void *data, size_t datalen, struct key *keyring, struct key *instkey) { int ret; if (keyring) down_write(&keyring->sem); ret = __key_instantiate_and_link(key, data, datalen, keyring, instkey); if (keyring) up_write(&keyring->sem); return ret; } /* end key_instantiate_and_link() */ EXPORT_SYMBOL(key_instantiate_and_link); /*****************************************************************************/ /* * negatively instantiate a key and link it into the target keyring atomically */ int key_negate_and_link(struct key *key, unsigned timeout, struct key *keyring, struct key *instkey) { struct timespec now; int ret, awaken; key_check(key); key_check(keyring);