/* key.c: basic authentication token and access key management
*
- * Copyright (C) 2004-6 Red Hat, Inc. All Rights Reserved.
+ * Copyright (C) 2004 Red Hat, Inc. All Rights Reserved.
* Written by David Howells (dhowells@redhat.com)
*
* This program is free software; you can redistribute it and/or
#include <linux/module.h>
#include <linux/init.h>
-#include <linux/poison.h>
#include <linux/sched.h>
#include <linux/slab.h>
#include <linux/security.h>
#include <linux/workqueue.h>
-#include <linux/random.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);
/*****************************************************************************/
/*
* assign a key the next unique serial number
- * - these are assigned randomly to avoid security issues through covert
- * channel problems
+ * - 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;
- /* propose a random serial number and look for a hole for it in the
- * serial number tree */
- do {
- get_random_bytes(&key->serial, sizeof(key->serial));
-
- key->serial >>= 1; /* negative numbers are not permitted */
- } while (key->serial < 3);
-
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;
/* we found a key with the proposed serial number - walk the tree from
* that point looking for the next unused serial number */
-serial_exists:
+ serial_exists:
for (;;) {
- key->serial++;
+ key->serial = key_serial_next;
if (key->serial < 2)
key->serial = 2;
+ key_serial_next = key->serial + 1;
- if (!rb_parent(parent))
+ if (!parent->rb_parent)
p = &key_serial_tree.rb_node;
- else if (rb_parent(parent)->rb_left == parent)
- p = &(rb_parent(parent)->rb_left);
+ else if (parent->rb_parent->rb_left == parent)
+ p = &parent->rb_parent->rb_left;
else
- p = &(rb_parent(parent)->rb_right);
+ p = &parent->rb_parent->rb_right;
parent = rb_next(parent);
if (!parent)
}
/* we've found a suitable hole - arrange for this key to occupy it */
-insert_here:
+ insert_here:
rb_link_node(&key->serial_node, parent, p);
rb_insert_color(&key->serial_node, &key_serial_tree);
* 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, unsigned long flags)
+ uid_t uid, gid_t gid, key_perm_t perm,
+ int not_in_quota)
{
struct key_user *user = NULL;
struct key *key;
/* check that the user's quota permits allocation of another key and
* its description */
- if (!(flags & KEY_ALLOC_NOT_IN_QUOTA)) {
+ if (!not_in_quota) {
spin_lock(&user->lock);
- if (!(flags & KEY_ALLOC_QUOTA_OVERRUN)) {
- if (user->qnkeys + 1 >= KEYQUOTA_MAX_KEYS ||
- user->qnbytes + quotalen >= KEYQUOTA_MAX_BYTES
- )
- goto no_quota;
- }
+ if (user->qnkeys + 1 >= KEYQUOTA_MAX_KEYS &&
+ user->qnbytes + quotalen >= KEYQUOTA_MAX_BYTES
+ )
+ goto no_quota;
user->qnkeys++;
user->qnbytes += quotalen;
key->payload.data = NULL;
key->security = NULL;
- if (!(flags & KEY_ALLOC_NOT_IN_QUOTA))
+ if (!not_in_quota)
key->flags |= 1 << KEY_FLAG_IN_QUOTA;
memset(&key->type_data, 0, sizeof(key->type_data));
#endif
/* let the security module know about the key */
- ret = security_key_alloc(key, ctx, flags);
+ ret = security_key_alloc(key);
if (ret < 0)
goto security_error;
security_error:
kfree(key->description);
kmem_cache_free(key_jar, key);
- if (!(flags & KEY_ALLOC_NOT_IN_QUOTA)) {
+ if (!not_in_quota) {
spin_lock(&user->lock);
user->qnkeys--;
user->qnbytes -= quotalen;
no_memory_3:
kmem_cache_free(key_jar, key);
no_memory_2:
- if (!(flags & KEY_ALLOC_NOT_IN_QUOTA)) {
+ if (!not_in_quota) {
spin_lock(&user->lock);
user->qnkeys--;
user->qnbytes -= quotalen;
const char *description,
const void *payload,
size_t plen,
- unsigned long flags)
+ int not_in_quota)
{
struct key_type *ktype;
struct key *keyring, *key = NULL;
goto error_3;
}
- /* if it's possible to update this type of key, search for an existing
- * key of the same type and description in the destination keyring and
- * update that instead if possible
+ /* search for an existing key of the same type and description in the
+ * destination keyring
*/
- if (ktype->update) {
- key_ref = __keyring_search_one(keyring_ref, ktype, description,
- 0);
- if (!IS_ERR(key_ref))
- goto found_matching_key;
- }
+ key_ref = __keyring_search_one(keyring_ref, ktype, description, 0);
+ if (!IS_ERR(key_ref))
+ goto found_matching_key;
/* decide on the permissions we want */
perm = KEY_POS_VIEW | KEY_POS_SEARCH | KEY_POS_LINK | KEY_POS_SETATTR;
/* allocate a new key */
key = key_alloc(ktype, description, current->fsuid, current->fsgid,
- current, perm, flags);
+ perm, not_in_quota);
if (IS_ERR(key)) {
key_ref = ERR_PTR(PTR_ERR(key));
goto error_3;
* it */
down_write(&key->sem);
set_bit(KEY_FLAG_REVOKED, &key->flags);
-
- if (key->type->revoke)
- key->type->revoke(key);
-
up_write(&key->sem);
} /* end key_revoke() */
if (key->type == ktype) {
if (ktype->destroy)
ktype->destroy(key);
- memset(&key->payload, KEY_DESTROY, sizeof(key->payload));
+ memset(&key->payload, 0xbd, sizeof(key->payload));
}
}
git://git.onelab.eu / linux-2.6.git / blobdiff