security: Yama LSM
[linux-3.10.git] / security / yama / yama_lsm.c
1 /*
2  * Yama Linux Security Module
3  *
4  * Author: Kees Cook <keescook@chromium.org>
5  *
6  * Copyright (C) 2010 Canonical, Ltd.
7  * Copyright (C) 2011 The Chromium OS Authors.
8  *
9  * This program is free software; you can redistribute it and/or modify
10  * it under the terms of the GNU General Public License version 2, as
11  * published by the Free Software Foundation.
12  *
13  */
14
15 #include <linux/security.h>
16 #include <linux/sysctl.h>
17 #include <linux/ptrace.h>
18 #include <linux/prctl.h>
19 #include <linux/ratelimit.h>
20
21 static int ptrace_scope = 1;
22
23 /* describe a ptrace relationship for potential exception */
24 struct ptrace_relation {
25         struct task_struct *tracer;
26         struct task_struct *tracee;
27         struct list_head node;
28 };
29
30 static LIST_HEAD(ptracer_relations);
31 static DEFINE_SPINLOCK(ptracer_relations_lock);
32
33 /**
34  * yama_ptracer_add - add/replace an exception for this tracer/tracee pair
35  * @tracer: the task_struct of the process doing the ptrace
36  * @tracee: the task_struct of the process to be ptraced
37  *
38  * Each tracee can have, at most, one tracer registered. Each time this
39  * is called, the prior registered tracer will be replaced for the tracee.
40  *
41  * Returns 0 if relationship was added, -ve on error.
42  */
43 static int yama_ptracer_add(struct task_struct *tracer,
44                             struct task_struct *tracee)
45 {
46         int rc = 0;
47         struct ptrace_relation *added;
48         struct ptrace_relation *entry, *relation = NULL;
49
50         added = kmalloc(sizeof(*added), GFP_KERNEL);
51         if (!added)
52                 return -ENOMEM;
53
54         spin_lock_bh(&ptracer_relations_lock);
55         list_for_each_entry(entry, &ptracer_relations, node)
56                 if (entry->tracee == tracee) {
57                         relation = entry;
58                         break;
59                 }
60         if (!relation) {
61                 relation = added;
62                 relation->tracee = tracee;
63                 list_add(&relation->node, &ptracer_relations);
64         }
65         relation->tracer = tracer;
66
67         spin_unlock_bh(&ptracer_relations_lock);
68         if (added != relation)
69                 kfree(added);
70
71         return rc;
72 }
73
74 /**
75  * yama_ptracer_del - remove exceptions related to the given tasks
76  * @tracer: remove any relation where tracer task matches
77  * @tracee: remove any relation where tracee task matches
78  */
79 static void yama_ptracer_del(struct task_struct *tracer,
80                              struct task_struct *tracee)
81 {
82         struct ptrace_relation *relation, *safe;
83
84         spin_lock_bh(&ptracer_relations_lock);
85         list_for_each_entry_safe(relation, safe, &ptracer_relations, node)
86                 if (relation->tracee == tracee ||
87                     relation->tracer == tracer) {
88                         list_del(&relation->node);
89                         kfree(relation);
90                 }
91         spin_unlock_bh(&ptracer_relations_lock);
92 }
93
94 /**
95  * yama_task_free - check for task_pid to remove from exception list
96  * @task: task being removed
97  */
98 static void yama_task_free(struct task_struct *task)
99 {
100         yama_ptracer_del(task, task);
101 }
102
103 /**
104  * yama_task_prctl - check for Yama-specific prctl operations
105  * @option: operation
106  * @arg2: argument
107  * @arg3: argument
108  * @arg4: argument
109  * @arg5: argument
110  *
111  * Return 0 on success, -ve on error.  -ENOSYS is returned when Yama
112  * does not handle the given option.
113  */
114 static int yama_task_prctl(int option, unsigned long arg2, unsigned long arg3,
115                            unsigned long arg4, unsigned long arg5)
116 {
117         int rc;
118         struct task_struct *myself = current;
119
120         rc = cap_task_prctl(option, arg2, arg3, arg4, arg5);
121         if (rc != -ENOSYS)
122                 return rc;
123
124         switch (option) {
125         case PR_SET_PTRACER:
126                 /* Since a thread can call prctl(), find the group leader
127                  * before calling _add() or _del() on it, since we want
128                  * process-level granularity of control. The tracer group
129                  * leader checking is handled later when walking the ancestry
130                  * at the time of PTRACE_ATTACH check.
131                  */
132                 rcu_read_lock();
133                 if (!thread_group_leader(myself))
134                         myself = rcu_dereference(myself->group_leader);
135                 get_task_struct(myself);
136                 rcu_read_unlock();
137
138                 if (arg2 == 0) {
139                         yama_ptracer_del(NULL, myself);
140                         rc = 0;
141                 } else {
142                         struct task_struct *tracer;
143
144                         rcu_read_lock();
145                         tracer = find_task_by_vpid(arg2);
146                         if (tracer)
147                                 get_task_struct(tracer);
148                         else
149                                 rc = -EINVAL;
150                         rcu_read_unlock();
151
152                         if (tracer) {
153                                 rc = yama_ptracer_add(tracer, myself);
154                                 put_task_struct(tracer);
155                         }
156                 }
157
158                 put_task_struct(myself);
159                 break;
160         }
161
162         return rc;
163 }
164
165 /**
166  * task_is_descendant - walk up a process family tree looking for a match
167  * @parent: the process to compare against while walking up from child
168  * @child: the process to start from while looking upwards for parent
169  *
170  * Returns 1 if child is a descendant of parent, 0 if not.
171  */
172 static int task_is_descendant(struct task_struct *parent,
173                               struct task_struct *child)
174 {
175         int rc = 0;
176         struct task_struct *walker = child;
177
178         if (!parent || !child)
179                 return 0;
180
181         rcu_read_lock();
182         if (!thread_group_leader(parent))
183                 parent = rcu_dereference(parent->group_leader);
184         while (walker->pid > 0) {
185                 if (!thread_group_leader(walker))
186                         walker = rcu_dereference(walker->group_leader);
187                 if (walker == parent) {
188                         rc = 1;
189                         break;
190                 }
191                 walker = rcu_dereference(walker->real_parent);
192         }
193         rcu_read_unlock();
194
195         return rc;
196 }
197
198 /**
199  * ptracer_exception_found - tracer registered as exception for this tracee
200  * @tracer: the task_struct of the process attempting ptrace
201  * @tracee: the task_struct of the process to be ptraced
202  *
203  * Returns 1 if tracer has is ptracer exception ancestor for tracee.
204  */
205 static int ptracer_exception_found(struct task_struct *tracer,
206                                    struct task_struct *tracee)
207 {
208         int rc = 0;
209         struct ptrace_relation *relation;
210         struct task_struct *parent = NULL;
211
212         spin_lock_bh(&ptracer_relations_lock);
213         rcu_read_lock();
214         if (!thread_group_leader(tracee))
215                 tracee = rcu_dereference(tracee->group_leader);
216         list_for_each_entry(relation, &ptracer_relations, node)
217                 if (relation->tracee == tracee) {
218                         parent = relation->tracer;
219                         break;
220                 }
221
222         if (task_is_descendant(parent, tracer))
223                 rc = 1;
224         rcu_read_unlock();
225         spin_unlock_bh(&ptracer_relations_lock);
226
227         return rc;
228 }
229
230 /**
231  * yama_ptrace_access_check - validate PTRACE_ATTACH calls
232  * @child: task that current task is attempting to ptrace
233  * @mode: ptrace attach mode
234  *
235  * Returns 0 if following the ptrace is allowed, -ve on error.
236  */
237 static int yama_ptrace_access_check(struct task_struct *child,
238                                     unsigned int mode)
239 {
240         int rc;
241
242         /* If standard caps disallows it, so does Yama.  We should
243          * only tighten restrictions further.
244          */
245         rc = cap_ptrace_access_check(child, mode);
246         if (rc)
247                 return rc;
248
249         /* require ptrace target be a child of ptracer on attach */
250         if (mode == PTRACE_MODE_ATTACH &&
251             ptrace_scope &&
252             !task_is_descendant(current, child) &&
253             !ptracer_exception_found(current, child) &&
254             !capable(CAP_SYS_PTRACE))
255                 rc = -EPERM;
256
257         if (rc) {
258                 char name[sizeof(current->comm)];
259                 printk_ratelimited(KERN_NOTICE "ptrace of non-child"
260                         " pid %d was attempted by: %s (pid %d)\n",
261                         child->pid,
262                         get_task_comm(name, current),
263                         current->pid);
264         }
265
266         return rc;
267 }
268
269 static struct security_operations yama_ops = {
270         .name =                 "yama",
271
272         .ptrace_access_check =  yama_ptrace_access_check,
273         .task_prctl =           yama_task_prctl,
274         .task_free =            yama_task_free,
275 };
276
277 #ifdef CONFIG_SYSCTL
278 static int zero;
279 static int one = 1;
280
281 struct ctl_path yama_sysctl_path[] = {
282         { .procname = "kernel", },
283         { .procname = "yama", },
284         { }
285 };
286
287 static struct ctl_table yama_sysctl_table[] = {
288         {
289                 .procname       = "ptrace_scope",
290                 .data           = &ptrace_scope,
291                 .maxlen         = sizeof(int),
292                 .mode           = 0644,
293                 .proc_handler   = proc_dointvec_minmax,
294                 .extra1         = &zero,
295                 .extra2         = &one,
296         },
297         { }
298 };
299 #endif /* CONFIG_SYSCTL */
300
301 static __init int yama_init(void)
302 {
303         if (!security_module_enable(&yama_ops))
304                 return 0;
305
306         printk(KERN_INFO "Yama: becoming mindful.\n");
307
308         if (register_security(&yama_ops))
309                 panic("Yama: kernel registration failed.\n");
310
311 #ifdef CONFIG_SYSCTL
312         if (!register_sysctl_paths(yama_sysctl_path, yama_sysctl_table))
313                 panic("Yama: sysctl registration failed.\n");
314 #endif
315
316         return 0;
317 }
318
319 security_initcall(yama_init);