Skip to contentSkip to conversation

Keys: Fix race between two instantiators of a key

PATCH New David Howells 1 participant 1 message May 26, 2006

Subsystems (3)
lore
Share & tools
lore

David Howells

author maintainer
#0 lore raw

PATCH 1/1 Keys: Fix race between two instantiators of a key

The attached patch adds a revocation notification method to the key type and calls it whilst the key's semaphore is still write-locked after setting the revocation flag.

The patch then uses this to maintain a reference on the task_struct of the process that calls request_key() for as long as the authorisation key remains unrevoked.

This fixes a potential race between two processes both of which have assumed the authority to instantiate a key (one may have forked the other for example). The problem is that there's no locking around the check for revocation of the auth key and the use of the task_struct it points to, nor does the auth key keep a reference on the task_struct.

Access to the "context" pointer in the auth key must thenceforth be done with the auth key semaphore held. The revocation method is called with the target key semaphore held write-locked and the search of the context process's keyrings is done with the auth key semaphore read-locked.

The check for the revocation state of the auth key just prior to searching it is done after the auth key is read-locked for the search. This ensures that the auth key can't be revoked between the check and the search.

The revocation notification method is added so that the context task_struct can be released as soon as instantiation happens rather than waiting for the auth key to be destroyed, thus avoiding the unnecessary pinning of the requesting process.

---
warthog>diffstat -p1 keys-revoke-2617rc5.diff

 Documentation/keys.txt           |   10 ++++++++
 include/linux/key.h              |    5 ++++
 security/keys/key.c              |    4 +++
 security/keys/process_keys.c     |   43 +++++++++++++++++++++++--------------
 security/keys/request_key_auth.c |   45 ++++++++++++++++++++++++++++++++++++++-
 5 files changed, 90 insertions(+), 17 deletions(-)
Documentation/keys.txt +10 -0
diff -uNrp linux-2.6.17-rc5/Documentation/keys.txt linux-2.6.17-rc5-keys/Documentation/keys.txt
@@ -935,6 +935,16 @@ The structure has a number of fields, so
      It is not safe to sleep in this method; the caller may hold spinlocks.
 
 
+ (*) void (*revoke)(struct key *key);
+
+     This method is optional.  It is called to discard part of the payload
+     data upon a key being revoked.  The caller will have the key semaphore
+     write-locked.
+
+     It is safe to sleep in this method, though care should be taken to avoid
+     a deadlock against the key semaphore.
+
+
  (*) void (*destroy)(struct key *key);
 
      This method is optional. It is called to discard the payload data on a key
include/linux/key.h +5 -0
diff -uNrp linux-2.6.17-rc5/include/linux/key.h linux-2.6.17-rc5-keys/include/linux/key.h
@@ -205,6 +205,11 @@ struct key_type {
 	/* match a key against a description */
 	int (*match)(const struct key *key, const void *desc);
 
+	/* clear some of the data from a key on revokation (optional)
+	 * - the key's semaphore will be write-locked by the caller
+	 */
+	void (*revoke)(struct key *key);
+
 	/* clear the data from a key (optional) */
 	void (*destroy)(struct key *key);
 
security/keys/key.c +4 -0
diff -uNrp linux-2.6.17-rc5/security/keys/key.c linux-2.6.17-rc5-keys/security/keys/key.c
@@ -907,6 +907,10 @@ void key_revoke(struct key *key)
 	 * 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() */
security/keys/process_keys.c +27 -16

60 lines not on this page · raw message

security/keys/request_key_auth.c +44 -1

91 lines not on this page · raw message