]>
Commit | Line | Data |
---|---|---|
1 | /* audit -- definition of audit_context structure and supporting types | |
2 | * | |
3 | * Copyright 2003-2004 Red Hat, Inc. | |
4 | * Copyright 2005 Hewlett-Packard Development Company, L.P. | |
5 | * Copyright 2005 IBM Corporation | |
6 | * | |
7 | * This program is free software; you can redistribute it and/or modify | |
8 | * it under the terms of the GNU General Public License as published by | |
9 | * the Free Software Foundation; either version 2 of the License, or | |
10 | * (at your option) any later version. | |
11 | * | |
12 | * This program is distributed in the hope that it will be useful, | |
13 | * but WITHOUT ANY WARRANTY; without even the implied warranty of | |
14 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
15 | * GNU General Public License for more details. | |
16 | * | |
17 | * You should have received a copy of the GNU General Public License | |
18 | * along with this program; if not, write to the Free Software | |
19 | * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA | |
20 | */ | |
21 | ||
22 | #include <linux/fs.h> | |
23 | #include <linux/audit.h> | |
24 | #include <linux/skbuff.h> | |
25 | #include <uapi/linux/mqueue.h> | |
26 | ||
27 | /* 0 = no checking | |
28 | 1 = put_count checking | |
29 | 2 = verbose put_count checking | |
30 | */ | |
31 | #define AUDIT_DEBUG 0 | |
32 | ||
33 | /* AUDIT_NAMES is the number of slots we reserve in the audit_context | |
34 | * for saving names from getname(). If we get more names we will allocate | |
35 | * a name dynamically and also add those to the list anchored by names_list. */ | |
36 | #define AUDIT_NAMES 5 | |
37 | ||
38 | /* At task start time, the audit_state is set in the audit_context using | |
39 | a per-task filter. At syscall entry, the audit_state is augmented by | |
40 | the syscall filter. */ | |
41 | enum audit_state { | |
42 | AUDIT_DISABLED, /* Do not create per-task audit_context. | |
43 | * No syscall-specific audit records can | |
44 | * be generated. */ | |
45 | AUDIT_BUILD_CONTEXT, /* Create the per-task audit_context, | |
46 | * and fill it in at syscall | |
47 | * entry time. This makes a full | |
48 | * syscall record available if some | |
49 | * other part of the kernel decides it | |
50 | * should be recorded. */ | |
51 | AUDIT_RECORD_CONTEXT /* Create the per-task audit_context, | |
52 | * always fill it in at syscall entry | |
53 | * time, and always write out the audit | |
54 | * record at syscall exit time. */ | |
55 | }; | |
56 | ||
57 | /* Rule lists */ | |
58 | struct audit_watch; | |
59 | struct audit_tree; | |
60 | struct audit_chunk; | |
61 | ||
62 | struct audit_entry { | |
63 | struct list_head list; | |
64 | struct rcu_head rcu; | |
65 | struct audit_krule rule; | |
66 | }; | |
67 | ||
68 | struct audit_cap_data { | |
69 | kernel_cap_t permitted; | |
70 | kernel_cap_t inheritable; | |
71 | union { | |
72 | unsigned int fE; /* effective bit of file cap */ | |
73 | kernel_cap_t effective; /* effective set of process */ | |
74 | }; | |
75 | }; | |
76 | ||
77 | /* When fs/namei.c:getname() is called, we store the pointer in name and | |
78 | * we don't let putname() free it (instead we free all of the saved | |
79 | * pointers at syscall exit time). | |
80 | * | |
81 | * Further, in fs/namei.c:path_lookup() we store the inode and device. | |
82 | */ | |
83 | struct audit_names { | |
84 | struct list_head list; /* audit_context->names_list */ | |
85 | ||
86 | struct filename *name; | |
87 | int name_len; /* number of chars to log */ | |
88 | bool hidden; /* don't log this record */ | |
89 | bool name_put; /* call __putname()? */ | |
90 | ||
91 | unsigned long ino; | |
92 | dev_t dev; | |
93 | umode_t mode; | |
94 | kuid_t uid; | |
95 | kgid_t gid; | |
96 | dev_t rdev; | |
97 | u32 osid; | |
98 | struct audit_cap_data fcap; | |
99 | unsigned int fcap_ver; | |
100 | unsigned char type; /* record type */ | |
101 | /* | |
102 | * This was an allocated audit_names and not from the array of | |
103 | * names allocated in the task audit context. Thus this name | |
104 | * should be freed on syscall exit. | |
105 | */ | |
106 | bool should_free; | |
107 | }; | |
108 | ||
109 | /* The per-task audit context. */ | |
110 | struct audit_context { | |
111 | int dummy; /* must be the first element */ | |
112 | int in_syscall; /* 1 if task is in a syscall */ | |
113 | enum audit_state state, current_state; | |
114 | unsigned int serial; /* serial number for record */ | |
115 | int major; /* syscall number */ | |
116 | struct timespec ctime; /* time of syscall entry */ | |
117 | unsigned long argv[4]; /* syscall arguments */ | |
118 | long return_code;/* syscall return code */ | |
119 | u64 prio; | |
120 | int return_valid; /* return code is valid */ | |
121 | /* | |
122 | * The names_list is the list of all audit_names collected during this | |
123 | * syscall. The first AUDIT_NAMES entries in the names_list will | |
124 | * actually be from the preallocated_names array for performance | |
125 | * reasons. Except during allocation they should never be referenced | |
126 | * through the preallocated_names array and should only be found/used | |
127 | * by running the names_list. | |
128 | */ | |
129 | struct audit_names preallocated_names[AUDIT_NAMES]; | |
130 | int name_count; /* total records in names_list */ | |
131 | struct list_head names_list; /* struct audit_names->list anchor */ | |
132 | char *filterkey; /* key for rule that triggered record */ | |
133 | struct path pwd; | |
134 | struct audit_aux_data *aux; | |
135 | struct audit_aux_data *aux_pids; | |
136 | struct sockaddr_storage *sockaddr; | |
137 | size_t sockaddr_len; | |
138 | /* Save things to print about task_struct */ | |
139 | pid_t pid, ppid; | |
140 | kuid_t uid, euid, suid, fsuid; | |
141 | kgid_t gid, egid, sgid, fsgid; | |
142 | unsigned long personality; | |
143 | int arch; | |
144 | ||
145 | pid_t target_pid; | |
146 | kuid_t target_auid; | |
147 | kuid_t target_uid; | |
148 | unsigned int target_sessionid; | |
149 | u32 target_sid; | |
150 | char target_comm[TASK_COMM_LEN]; | |
151 | ||
152 | struct audit_tree_refs *trees, *first_trees; | |
153 | struct list_head killed_trees; | |
154 | int tree_count; | |
155 | ||
156 | int type; | |
157 | union { | |
158 | struct { | |
159 | int nargs; | |
160 | long args[6]; | |
161 | } socketcall; | |
162 | struct { | |
163 | kuid_t uid; | |
164 | kgid_t gid; | |
165 | umode_t mode; | |
166 | u32 osid; | |
167 | int has_perm; | |
168 | uid_t perm_uid; | |
169 | gid_t perm_gid; | |
170 | umode_t perm_mode; | |
171 | unsigned long qbytes; | |
172 | } ipc; | |
173 | struct { | |
174 | mqd_t mqdes; | |
175 | struct mq_attr mqstat; | |
176 | } mq_getsetattr; | |
177 | struct { | |
178 | mqd_t mqdes; | |
179 | int sigev_signo; | |
180 | } mq_notify; | |
181 | struct { | |
182 | mqd_t mqdes; | |
183 | size_t msg_len; | |
184 | unsigned int msg_prio; | |
185 | struct timespec abs_timeout; | |
186 | } mq_sendrecv; | |
187 | struct { | |
188 | int oflag; | |
189 | umode_t mode; | |
190 | struct mq_attr attr; | |
191 | } mq_open; | |
192 | struct { | |
193 | pid_t pid; | |
194 | struct audit_cap_data cap; | |
195 | } capset; | |
196 | struct { | |
197 | int fd; | |
198 | int flags; | |
199 | } mmap; | |
200 | struct { | |
201 | int argc; | |
202 | } execve; | |
203 | }; | |
204 | int fds[2]; | |
205 | ||
206 | #if AUDIT_DEBUG | |
207 | int put_count; | |
208 | int ino_count; | |
209 | #endif | |
210 | }; | |
211 | ||
212 | extern u32 audit_ever_enabled; | |
213 | ||
214 | extern void audit_copy_inode(struct audit_names *name, | |
215 | const struct dentry *dentry, | |
216 | const struct inode *inode); | |
217 | extern void audit_log_cap(struct audit_buffer *ab, char *prefix, | |
218 | kernel_cap_t *cap); | |
219 | extern void audit_log_fcaps(struct audit_buffer *ab, struct audit_names *name); | |
220 | extern void audit_log_name(struct audit_context *context, | |
221 | struct audit_names *n, struct path *path, | |
222 | int record_num, int *call_panic); | |
223 | ||
224 | extern int audit_pid; | |
225 | ||
226 | #define AUDIT_INODE_BUCKETS 32 | |
227 | extern struct list_head audit_inode_hash[AUDIT_INODE_BUCKETS]; | |
228 | ||
229 | static inline int audit_hash_ino(u32 ino) | |
230 | { | |
231 | return (ino & (AUDIT_INODE_BUCKETS-1)); | |
232 | } | |
233 | ||
234 | /* Indicates that audit should log the full pathname. */ | |
235 | #define AUDIT_NAME_FULL -1 | |
236 | ||
237 | extern int audit_match_class(int class, unsigned syscall); | |
238 | extern int audit_comparator(const u32 left, const u32 op, const u32 right); | |
239 | extern int audit_uid_comparator(kuid_t left, u32 op, kuid_t right); | |
240 | extern int audit_gid_comparator(kgid_t left, u32 op, kgid_t right); | |
241 | extern int parent_len(const char *path); | |
242 | extern int audit_compare_dname_path(const char *dname, const char *path, int plen); | |
243 | extern struct sk_buff *audit_make_reply(__u32 portid, int seq, int type, | |
244 | int done, int multi, | |
245 | const void *payload, int size); | |
246 | extern void audit_panic(const char *message); | |
247 | ||
248 | struct audit_netlink_list { | |
249 | __u32 portid; | |
250 | pid_t pid; | |
251 | struct sk_buff_head q; | |
252 | }; | |
253 | ||
254 | int audit_send_list(void *); | |
255 | ||
256 | struct audit_net { | |
257 | struct sock *nlsk; | |
258 | }; | |
259 | ||
260 | extern int selinux_audit_rule_update(void); | |
261 | ||
262 | extern struct mutex audit_filter_mutex; | |
263 | extern void audit_free_rule_rcu(struct rcu_head *); | |
264 | extern struct list_head audit_filter_list[]; | |
265 | ||
266 | extern struct audit_entry *audit_dupe_rule(struct audit_krule *old); | |
267 | ||
268 | /* audit watch functions */ | |
269 | #ifdef CONFIG_AUDIT_WATCH | |
270 | extern void audit_put_watch(struct audit_watch *watch); | |
271 | extern void audit_get_watch(struct audit_watch *watch); | |
272 | extern int audit_to_watch(struct audit_krule *krule, char *path, int len, u32 op); | |
273 | extern int audit_add_watch(struct audit_krule *krule, struct list_head **list); | |
274 | extern void audit_remove_watch_rule(struct audit_krule *krule); | |
275 | extern char *audit_watch_path(struct audit_watch *watch); | |
276 | extern int audit_watch_compare(struct audit_watch *watch, unsigned long ino, dev_t dev); | |
277 | #else | |
278 | #define audit_put_watch(w) {} | |
279 | #define audit_get_watch(w) {} | |
280 | #define audit_to_watch(k, p, l, o) (-EINVAL) | |
281 | #define audit_add_watch(k, l) (-EINVAL) | |
282 | #define audit_remove_watch_rule(k) BUG() | |
283 | #define audit_watch_path(w) "" | |
284 | #define audit_watch_compare(w, i, d) 0 | |
285 | ||
286 | #endif /* CONFIG_AUDIT_WATCH */ | |
287 | ||
288 | #ifdef CONFIG_AUDIT_TREE | |
289 | extern struct audit_chunk *audit_tree_lookup(const struct inode *); | |
290 | extern void audit_put_chunk(struct audit_chunk *); | |
291 | extern int audit_tree_match(struct audit_chunk *, struct audit_tree *); | |
292 | extern int audit_make_tree(struct audit_krule *, char *, u32); | |
293 | extern int audit_add_tree_rule(struct audit_krule *); | |
294 | extern int audit_remove_tree_rule(struct audit_krule *); | |
295 | extern void audit_trim_trees(void); | |
296 | extern int audit_tag_tree(char *old, char *new); | |
297 | extern const char *audit_tree_path(struct audit_tree *); | |
298 | extern void audit_put_tree(struct audit_tree *); | |
299 | extern void audit_kill_trees(struct list_head *); | |
300 | #else | |
301 | #define audit_remove_tree_rule(rule) BUG() | |
302 | #define audit_add_tree_rule(rule) -EINVAL | |
303 | #define audit_make_tree(rule, str, op) -EINVAL | |
304 | #define audit_trim_trees() (void)0 | |
305 | #define audit_put_tree(tree) (void)0 | |
306 | #define audit_tag_tree(old, new) -EINVAL | |
307 | #define audit_tree_path(rule) "" /* never called */ | |
308 | #define audit_kill_trees(list) BUG() | |
309 | #endif | |
310 | ||
311 | extern char *audit_unpack_string(void **, size_t *, size_t); | |
312 | ||
313 | extern pid_t audit_sig_pid; | |
314 | extern kuid_t audit_sig_uid; | |
315 | extern u32 audit_sig_sid; | |
316 | ||
317 | #ifdef CONFIG_AUDITSYSCALL | |
318 | extern int __audit_signal_info(int sig, struct task_struct *t); | |
319 | static inline int audit_signal_info(int sig, struct task_struct *t) | |
320 | { | |
321 | if (unlikely((audit_pid && t->tgid == audit_pid) || | |
322 | (audit_signals && !audit_dummy_context()))) | |
323 | return __audit_signal_info(sig, t); | |
324 | return 0; | |
325 | } | |
326 | extern void audit_filter_inodes(struct task_struct *, struct audit_context *); | |
327 | extern struct list_head *audit_killed_trees(void); | |
328 | #else | |
329 | #define audit_signal_info(s,t) AUDIT_DISABLED | |
330 | #define audit_filter_inodes(t,c) AUDIT_DISABLED | |
331 | #endif | |
332 | ||
333 | extern struct mutex audit_cmd_mutex; |