Skip to contentSkip to conversation

Yama: turn process ancestry check into function

PATCH In review Kees Cook 4 participants 5 messages Jul 13, 2010 – Jul 20, 2010

Subsystems (2)
lore
Share & tools
lore

Kees Cook

author
#0 lore raw

PATCH 1/1 Yama: turn process ancestry check into function

This cleans up the ancestry check by separating it out into its own function, which makes the code a bit more readable. Additionally, it now checks for and uses the thread group leader since otherwise we may end up missing potential matches on attaches to threads.

---
 security/yama/yama_lsm.c |   55 ++++++++++++++++++++++++++++++++-------------
 1 files changed, 39 insertions(+), 16 deletions(-)
security/yama/yama_lsm.c +39 -16
index 72929d2..3b76386 100644
@@ -21,6 +21,40 @@ static int protected_sticky_symlinks = 1;
 static int protected_nonaccess_hardlinks = 1;
 
 /**
+ * task_is_descendant - walk up a process family tree looking for a match
+ * @parent: the process to compare against while walking up from child
+ * @child: the process to start from while looking upwards for parent
+ *
+ * Returns 1 if child is a descendant of parent, 0 if not.
+ */
+static int task_is_descendant(struct task_struct *parent,
+			      struct task_struct *child)
+{
+	int rc = 0;
+	struct task_struct *walker = child;
+
+	if (!parent || !child)
+		return 0;
+
+	rcu_read_lock();
+	read_lock(&tasklist_lock);
+	while (walker->pid > 0) {
+		if (!thread_group_leader(walker))
+			walker = walker->group_leader;
+		if (walker == parent) {
+			rc = 1;
+			break;
+		}
+		walker = walker->real_parent;
+	}
+	read_unlock(&tasklist_lock);
+	rcu_read_unlock();
+
+	return rc;
+}
+
+
+/**
  * yama_ptrace_access_check - validate PTRACE_ATTACH calls
  * @child: child task pointer
  * @mode: ptrace attach mode
@@ -37,22 +71,11 @@ static int yama_ptrace_access_check(struct task_struct *child,
 		return rc;
 
 	/* require ptrace target be a child of ptracer on attach */
-	if (mode == PTRACE_MODE_ATTACH && ptrace_scope &&
-	    !capable(CAP_SYS_PTRACE)) {
-		struct task_struct *walker = child;
-
-		rcu_read_lock();
-		read_lock(&tasklist_lock);
-		while (walker->pid > 0) {
-			if (walker == current)
-				break;
-			walker = walker->real_parent;
-		}
-		if (walker->pid == 0)
-			rc = -EPERM;
-		read_unlock(&tasklist_lock);
-		rcu_read_unlock();
-	}
+	if (mode == PTRACE_MODE_ATTACH &&
+	    ptrace_scope &&
+	    !task_is_descendant(current, child) &&
+	    !capable(CAP_SYS_PTRACE))
+		rc = -EPERM;
 
 	if (rc) {
 		char name[sizeof(current->comm)];
Signature · 6 lines
1.7.1


-- 
Kees Cook
Ubuntu Security Team
#1 lore raw

security/yama/yama_lsm.c static int protected_sticky_symlinks = 1; · line 37

Quoted 8 lines · Kees Cook
security/yama/yama_lsm.c +8 -0
+static int task_is_descendant(struct task_struct *parent,
+			      struct task_struct *child)
+{
+	int rc = 0;
+	struct task_struct *walker = child;
+
+	if (!parent || !child)
+		return 0;

parent (== current) is !NULL and
child (in original code) is !NULL.
You can remove this check unless you are planning to call this function from other places.

security/yama/yama_lsm.c static int yama_ptrace_access_check(struct task_struct *child, · line 78

Quoted 5 lines
security/yama/yama_lsm.c +5 -0
+	if (mode == PTRACE_MODE_ATTACH &&
+	    ptrace_scope &&
+	    !task_is_descendant(current, child) &&
+	    !capable(CAP_SYS_PTRACE))
+		rc = -EPERM;

I don't know how heavy capable(CAP_SYS_PTRACE) is. But checking !capable(CAP_SYS_PTRACE) before !task_is_descendant(current, child) might be lighter.

author
#2 lore raw
Quoted 14 lines · Tetsuo Handa

security/yama/yama_lsm.c static int protected_sticky_symlinks = 1; · line 37

Quoted 8 lines · Kees Cook
security/yama/yama_lsm.c +8 -0
+static int task_is_descendant(struct task_struct *parent,
+			      struct task_struct *child)
+{
+	int rc = 0;
+	struct task_struct *walker = child;
+
+	if (!parent || !child)
+		return 0;

parent (== current) is !NULL and
child (in original code) is !NULL.
You can remove this check unless you are planning to call this function from other places.

I'd like the flexibility to call it with NULLs. But yes, at present, it never will be NULL.

Quoted 9 lines

security/yama/yama_lsm.c static int yama_ptrace_access_check(struct task_struct *child, · line 78

Quoted 5 lines
security/yama/yama_lsm.c +5 -0
+	if (mode == PTRACE_MODE_ATTACH &&
+	    ptrace_scope &&
+	    !task_is_descendant(current, child) &&
+	    !capable(CAP_SYS_PTRACE))
+		rc = -EPERM;

I don't know how heavy capable(CAP_SYS_PTRACE) is. But checking !capable(CAP_SYS_PTRACE) before !task_is_descendant(current, child) might be lighter.

That's the order I had before, but in looking at some of the other code, it seemed like moving it to the end made more logical sense. Since checking PTRACE attach isn't a common or time-sensitive operation, I figured trying to tune it wasn't critical.

-Kees

Signature · 2 lines
Kees Cook
Ubuntu Security Team
maintainer
#3 lore raw
Quoted 11 lines · Kees Cook
Quoted 9 lines · Tetsuo Handa

security/yama/yama_lsm.c static int yama_ptrace_access_check(struct task_struct *child, · line 78

Quoted 5 lines
security/yama/yama_lsm.c +5 -0
+	if (mode == PTRACE_MODE_ATTACH &&
+	    ptrace_scope &&
+	    !task_is_descendant(current, child) &&
+	    !capable(CAP_SYS_PTRACE))
+		rc = -EPERM;

I don't know how heavy capable(CAP_SYS_PTRACE) is. But checking !capable(CAP_SYS_PTRACE) before !task_is_descendant(current, child) might be lighter.

Quoted 4 lines

That's the order I had before, but in looking at some of the other code, it seemed like moving it to the end made more logical sense. Since checking PTRACE attach isn't a common or time-sensitive operation, I figured trying to tune it wasn't critical.

Yes the reason to keep it like this is that capable(CAP_SYS_PTRACE) will set PF_SUPERPRIV if it passes. You don't want to do that unless the capability was actually required.

-serge

maintainer
#4 lore raw
In reply to Kees Cook
Quoted 6 lines · Kees Cook

This cleans up the ancestry check by separating it out into its own function, which makes the code a bit more readable. Additionally, it now checks for and uses the thread group leader since otherwise we may end up missing potential matches on attaches to threads.

Applied to
git://git.kernel.org/pub/scm/linux/kernel/git/jmorris/security-testing-2.6#next

Signature · 2 lines
James Morris
<[email protected]>