audit: fix mq_open and mq_unlink to add the MQ root as a hidden parent audit_names...
[linux-3.10.git] / include / linux / audit.h
1 /* audit.h -- Auditing support
2  *
3  * Copyright 2003-2004 Red Hat Inc., Durham, North Carolina.
4  * All Rights Reserved.
5  *
6  * This program is free software; you can redistribute it and/or modify
7  * it under the terms of the GNU General Public License as published by
8  * the Free Software Foundation; either version 2 of the License, or
9  * (at your option) any later version.
10  *
11  * This program is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14  * GNU General Public License for more details.
15  *
16  * You should have received a copy of the GNU General Public License
17  * along with this program; if not, write to the Free Software
18  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
19  *
20  * Written by Rickard E. (Rik) Faith <faith@redhat.com>
21  *
22  */
23 #ifndef _LINUX_AUDIT_H_
24 #define _LINUX_AUDIT_H_
25
26 #include <linux/sched.h>
27 #include <linux/ptrace.h>
28 #include <uapi/linux/audit.h>
29
30 struct audit_sig_info {
31         uid_t           uid;
32         pid_t           pid;
33         char            ctx[0];
34 };
35
36 struct audit_buffer;
37 struct audit_context;
38 struct inode;
39 struct netlink_skb_parms;
40 struct path;
41 struct linux_binprm;
42 struct mq_attr;
43 struct mqstat;
44 struct audit_watch;
45 struct audit_tree;
46
47 struct audit_krule {
48         int                     vers_ops;
49         u32                     flags;
50         u32                     listnr;
51         u32                     action;
52         u32                     mask[AUDIT_BITMASK_SIZE];
53         u32                     buflen; /* for data alloc on list rules */
54         u32                     field_count;
55         char                    *filterkey; /* ties events to rules */
56         struct audit_field      *fields;
57         struct audit_field      *arch_f; /* quick access to arch field */
58         struct audit_field      *inode_f; /* quick access to an inode field */
59         struct audit_watch      *watch; /* associated watch */
60         struct audit_tree       *tree;  /* associated watched tree */
61         struct list_head        rlist;  /* entry in audit_{watch,tree}.rules list */
62         struct list_head        list;   /* for AUDIT_LIST* purposes only */
63         u64                     prio;
64 };
65
66 struct audit_field {
67         u32                             type;
68         u32                             val;
69         kuid_t                          uid;
70         kgid_t                          gid;
71         u32                             op;
72         char                            *lsm_str;
73         void                            *lsm_rule;
74 };
75
76 extern int __init audit_register_class(int class, unsigned *list);
77 extern int audit_classify_syscall(int abi, unsigned syscall);
78 extern int audit_classify_arch(int arch);
79
80 /* audit_names->type values */
81 #define AUDIT_TYPE_UNKNOWN      0       /* we don't know yet */
82 #define AUDIT_TYPE_NORMAL       1       /* a "normal" audit record */
83 #define AUDIT_TYPE_PARENT       2       /* a parent audit record */
84 #define AUDIT_TYPE_CHILD_DELETE 3       /* a child being deleted */
85 #define AUDIT_TYPE_CHILD_CREATE 4       /* a child being created */
86
87 /* maximized args number that audit_socketcall can process */
88 #define AUDITSC_ARGS            6
89
90 struct filename;
91
92 extern void audit_log_session_info(struct audit_buffer *ab);
93
94 #ifdef CONFIG_AUDITSYSCALL
95 /* These are defined in auditsc.c */
96                                 /* Public API */
97 extern int  audit_alloc(struct task_struct *task);
98 extern void __audit_free(struct task_struct *task);
99 extern void __audit_syscall_entry(int arch,
100                                   int major, unsigned long a0, unsigned long a1,
101                                   unsigned long a2, unsigned long a3);
102 extern void __audit_syscall_exit(int ret_success, long ret_value);
103 extern struct filename *__audit_reusename(const __user char *uptr);
104 extern void __audit_getname(struct filename *name);
105 extern void audit_putname(struct filename *name);
106
107 #define AUDIT_INODE_PARENT      1       /* dentry represents the parent */
108 #define AUDIT_INODE_HIDDEN      2       /* audit record should be hidden */
109 extern void __audit_inode(struct filename *name, const struct dentry *dentry,
110                                 unsigned int flags);
111 extern void __audit_inode_child(const struct inode *parent,
112                                 const struct dentry *dentry,
113                                 const unsigned char type);
114 extern void __audit_seccomp(unsigned long syscall, long signr, int code);
115 extern void __audit_ptrace(struct task_struct *t);
116
117 static inline int audit_dummy_context(void)
118 {
119         void *p = current->audit_context;
120         return !p || *(int *)p;
121 }
122 static inline void audit_free(struct task_struct *task)
123 {
124         if (unlikely(task->audit_context))
125                 __audit_free(task);
126 }
127 static inline void audit_syscall_entry(int arch, int major, unsigned long a0,
128                                        unsigned long a1, unsigned long a2,
129                                        unsigned long a3)
130 {
131         if (unlikely(current->audit_context))
132                 __audit_syscall_entry(arch, major, a0, a1, a2, a3);
133 }
134 static inline void audit_syscall_exit(void *pt_regs)
135 {
136         if (unlikely(current->audit_context)) {
137                 int success = is_syscall_success(pt_regs);
138                 int return_code = regs_return_value(pt_regs);
139
140                 __audit_syscall_exit(success, return_code);
141         }
142 }
143 static inline struct filename *audit_reusename(const __user char *name)
144 {
145         if (unlikely(!audit_dummy_context()))
146                 return __audit_reusename(name);
147         return NULL;
148 }
149 static inline void audit_getname(struct filename *name)
150 {
151         if (unlikely(!audit_dummy_context()))
152                 __audit_getname(name);
153 }
154 static inline void audit_inode(struct filename *name,
155                                 const struct dentry *dentry,
156                                 unsigned int parent) {
157         if (unlikely(!audit_dummy_context())) {
158                 unsigned int flags = 0;
159                 if (parent)
160                         flags |= AUDIT_INODE_PARENT;
161                 __audit_inode(name, dentry, flags);
162         }
163 }
164 static inline void audit_inode_parent_hidden(struct filename *name,
165                                                 const struct dentry *dentry)
166 {
167         if (unlikely(!audit_dummy_context()))
168                 __audit_inode(name, dentry,
169                                 AUDIT_INODE_PARENT | AUDIT_INODE_HIDDEN);
170 }
171 static inline void audit_inode_child(const struct inode *parent,
172                                      const struct dentry *dentry,
173                                      const unsigned char type) {
174         if (unlikely(!audit_dummy_context()))
175                 __audit_inode_child(parent, dentry, type);
176 }
177 void audit_core_dumps(long signr);
178
179 static inline void audit_seccomp(unsigned long syscall, long signr, int code)
180 {
181         /* Force a record to be reported if a signal was delivered. */
182         if (signr || unlikely(!audit_dummy_context()))
183                 __audit_seccomp(syscall, signr, code);
184 }
185
186 static inline void audit_ptrace(struct task_struct *t)
187 {
188         if (unlikely(!audit_dummy_context()))
189                 __audit_ptrace(t);
190 }
191
192                                 /* Private API (for audit.c only) */
193 extern unsigned int audit_serial(void);
194 extern int auditsc_get_stamp(struct audit_context *ctx,
195                               struct timespec *t, unsigned int *serial);
196 extern int audit_set_loginuid(kuid_t loginuid);
197
198 static inline kuid_t audit_get_loginuid(struct task_struct *tsk)
199 {
200         return tsk->loginuid;
201 }
202
203 static inline int audit_get_sessionid(struct task_struct *tsk)
204 {
205         return tsk->sessionid;
206 }
207
208 extern void __audit_ipc_obj(struct kern_ipc_perm *ipcp);
209 extern void __audit_ipc_set_perm(unsigned long qbytes, uid_t uid, gid_t gid, umode_t mode);
210 extern int __audit_bprm(struct linux_binprm *bprm);
211 extern int __audit_socketcall(int nargs, unsigned long *args);
212 extern int __audit_sockaddr(int len, void *addr);
213 extern void __audit_fd_pair(int fd1, int fd2);
214 extern void __audit_mq_open(int oflag, umode_t mode, struct mq_attr *attr);
215 extern void __audit_mq_sendrecv(mqd_t mqdes, size_t msg_len, unsigned int msg_prio, const struct timespec *abs_timeout);
216 extern void __audit_mq_notify(mqd_t mqdes, const struct sigevent *notification);
217 extern void __audit_mq_getsetattr(mqd_t mqdes, struct mq_attr *mqstat);
218 extern int __audit_log_bprm_fcaps(struct linux_binprm *bprm,
219                                   const struct cred *new,
220                                   const struct cred *old);
221 extern void __audit_log_capset(pid_t pid, const struct cred *new, const struct cred *old);
222 extern void __audit_mmap_fd(int fd, int flags);
223
224 static inline void audit_ipc_obj(struct kern_ipc_perm *ipcp)
225 {
226         if (unlikely(!audit_dummy_context()))
227                 __audit_ipc_obj(ipcp);
228 }
229 static inline void audit_fd_pair(int fd1, int fd2)
230 {
231         if (unlikely(!audit_dummy_context()))
232                 __audit_fd_pair(fd1, fd2);
233 }
234 static inline void audit_ipc_set_perm(unsigned long qbytes, uid_t uid, gid_t gid, umode_t mode)
235 {
236         if (unlikely(!audit_dummy_context()))
237                 __audit_ipc_set_perm(qbytes, uid, gid, mode);
238 }
239 static inline int audit_bprm(struct linux_binprm *bprm)
240 {
241         if (unlikely(!audit_dummy_context()))
242                 return __audit_bprm(bprm);
243         return 0;
244 }
245 static inline int audit_socketcall(int nargs, unsigned long *args)
246 {
247         if (unlikely(!audit_dummy_context()))
248                 return __audit_socketcall(nargs, args);
249         return 0;
250 }
251 static inline int audit_sockaddr(int len, void *addr)
252 {
253         if (unlikely(!audit_dummy_context()))
254                 return __audit_sockaddr(len, addr);
255         return 0;
256 }
257 static inline void audit_mq_open(int oflag, umode_t mode, struct mq_attr *attr)
258 {
259         if (unlikely(!audit_dummy_context()))
260                 __audit_mq_open(oflag, mode, attr);
261 }
262 static inline void audit_mq_sendrecv(mqd_t mqdes, size_t msg_len, unsigned int msg_prio, const struct timespec *abs_timeout)
263 {
264         if (unlikely(!audit_dummy_context()))
265                 __audit_mq_sendrecv(mqdes, msg_len, msg_prio, abs_timeout);
266 }
267 static inline void audit_mq_notify(mqd_t mqdes, const struct sigevent *notification)
268 {
269         if (unlikely(!audit_dummy_context()))
270                 __audit_mq_notify(mqdes, notification);
271 }
272 static inline void audit_mq_getsetattr(mqd_t mqdes, struct mq_attr *mqstat)
273 {
274         if (unlikely(!audit_dummy_context()))
275                 __audit_mq_getsetattr(mqdes, mqstat);
276 }
277
278 static inline int audit_log_bprm_fcaps(struct linux_binprm *bprm,
279                                        const struct cred *new,
280                                        const struct cred *old)
281 {
282         if (unlikely(!audit_dummy_context()))
283                 return __audit_log_bprm_fcaps(bprm, new, old);
284         return 0;
285 }
286
287 static inline void audit_log_capset(pid_t pid, const struct cred *new,
288                                    const struct cred *old)
289 {
290         if (unlikely(!audit_dummy_context()))
291                 __audit_log_capset(pid, new, old);
292 }
293
294 static inline void audit_mmap_fd(int fd, int flags)
295 {
296         if (unlikely(!audit_dummy_context()))
297                 __audit_mmap_fd(fd, flags);
298 }
299
300 extern int audit_n_rules;
301 extern int audit_signals;
302 #else /* CONFIG_AUDITSYSCALL */
303 static inline int audit_alloc(struct task_struct *task)
304 {
305         return 0;
306 }
307 static inline void audit_free(struct task_struct *task)
308 { }
309 static inline void audit_syscall_entry(int arch, int major, unsigned long a0,
310                                        unsigned long a1, unsigned long a2,
311                                        unsigned long a3)
312 { }
313 static inline void audit_syscall_exit(void *pt_regs)
314 { }
315 static inline int audit_dummy_context(void)
316 {
317         return 1;
318 }
319 static inline struct filename *audit_reusename(const __user char *name)
320 {
321         return NULL;
322 }
323 static inline void audit_getname(struct filename *name)
324 { }
325 static inline void audit_putname(struct filename *name)
326 { }
327 static inline void __audit_inode(struct filename *name,
328                                         const struct dentry *dentry,
329                                         unsigned int flags)
330 { }
331 static inline void __audit_inode_child(const struct inode *parent,
332                                         const struct dentry *dentry,
333                                         const unsigned char type)
334 { }
335 static inline void audit_inode(struct filename *name,
336                                 const struct dentry *dentry,
337                                 unsigned int parent)
338 { }
339 static inline void audit_inode_parent_hidden(struct filename *name,
340                                 const struct dentry *dentry)
341 { }
342 static inline void audit_inode_child(const struct inode *parent,
343                                      const struct dentry *dentry,
344                                      const unsigned char type)
345 { }
346 static inline void audit_core_dumps(long signr)
347 { }
348 static inline void __audit_seccomp(unsigned long syscall, long signr, int code)
349 { }
350 static inline void audit_seccomp(unsigned long syscall, long signr, int code)
351 { }
352 static inline int auditsc_get_stamp(struct audit_context *ctx,
353                               struct timespec *t, unsigned int *serial)
354 {
355         return 0;
356 }
357 static inline kuid_t audit_get_loginuid(struct task_struct *tsk)
358 {
359         return INVALID_UID;
360 }
361 static inline int audit_get_sessionid(struct task_struct *tsk)
362 {
363         return -1;
364 }
365 static inline void audit_ipc_obj(struct kern_ipc_perm *ipcp)
366 { }
367 static inline void audit_ipc_set_perm(unsigned long qbytes, uid_t uid,
368                                         gid_t gid, umode_t mode)
369 { }
370 static inline int audit_bprm(struct linux_binprm *bprm)
371 {
372         return 0;
373 }
374 static inline int audit_socketcall(int nargs, unsigned long *args)
375 {
376         return 0;
377 }
378 static inline void audit_fd_pair(int fd1, int fd2)
379 { }
380 static inline int audit_sockaddr(int len, void *addr)
381 {
382         return 0;
383 }
384 static inline void audit_mq_open(int oflag, umode_t mode, struct mq_attr *attr)
385 { }
386 static inline void audit_mq_sendrecv(mqd_t mqdes, size_t msg_len,
387                                      unsigned int msg_prio,
388                                      const struct timespec *abs_timeout)
389 { }
390 static inline void audit_mq_notify(mqd_t mqdes,
391                                    const struct sigevent *notification)
392 { }
393 static inline void audit_mq_getsetattr(mqd_t mqdes, struct mq_attr *mqstat)
394 { }
395 static inline int audit_log_bprm_fcaps(struct linux_binprm *bprm,
396                                        const struct cred *new,
397                                        const struct cred *old)
398 {
399         return 0;
400 }
401 static inline void audit_log_capset(pid_t pid, const struct cred *new,
402                                    const struct cred *old)
403 { }
404 static inline void audit_mmap_fd(int fd, int flags)
405 { }
406 static inline void audit_ptrace(struct task_struct *t)
407 { }
408 #define audit_n_rules 0
409 #define audit_signals 0
410 #endif /* CONFIG_AUDITSYSCALL */
411
412 static inline bool audit_loginuid_set(struct task_struct *tsk)
413 {
414         return uid_valid(audit_get_loginuid(tsk));
415 }
416
417 #ifdef CONFIG_AUDIT
418 /* These are defined in audit.c */
419                                 /* Public API */
420 extern __printf(4, 5)
421 void audit_log(struct audit_context *ctx, gfp_t gfp_mask, int type,
422                const char *fmt, ...);
423
424 extern struct audit_buffer *audit_log_start(struct audit_context *ctx, gfp_t gfp_mask, int type);
425 extern __printf(2, 3)
426 void audit_log_format(struct audit_buffer *ab, const char *fmt, ...);
427 extern void                 audit_log_end(struct audit_buffer *ab);
428 extern int                  audit_string_contains_control(const char *string,
429                                                           size_t len);
430 extern void                 audit_log_n_hex(struct audit_buffer *ab,
431                                           const unsigned char *buf,
432                                           size_t len);
433 extern void                 audit_log_n_string(struct audit_buffer *ab,
434                                                const char *buf,
435                                                size_t n);
436 extern void                 audit_log_n_untrustedstring(struct audit_buffer *ab,
437                                                         const char *string,
438                                                         size_t n);
439 extern void                 audit_log_untrustedstring(struct audit_buffer *ab,
440                                                       const char *string);
441 extern void                 audit_log_d_path(struct audit_buffer *ab,
442                                              const char *prefix,
443                                              const struct path *path);
444 extern void                 audit_log_key(struct audit_buffer *ab,
445                                           char *key);
446 extern void                 audit_log_link_denied(const char *operation,
447                                                   struct path *link);
448 extern void                 audit_log_lost(const char *message);
449 #ifdef CONFIG_SECURITY
450 extern void                 audit_log_secctx(struct audit_buffer *ab, u32 secid);
451 #else
452 static inline void          audit_log_secctx(struct audit_buffer *ab, u32 secid)
453 { }
454 #endif
455
456 extern int audit_log_task_context(struct audit_buffer *ab);
457 extern void audit_log_task_info(struct audit_buffer *ab,
458                                 struct task_struct *tsk);
459
460 extern int                  audit_update_lsm_rules(void);
461
462                                 /* Private API (for audit.c only) */
463 extern int audit_filter_user(int type);
464 extern int audit_filter_type(int type);
465 extern int  audit_receive_filter(int type, int pid, int seq,
466                                 void *data, size_t datasz);
467 extern int audit_enabled;
468 #else /* CONFIG_AUDIT */
469 static inline __printf(4, 5)
470 void audit_log(struct audit_context *ctx, gfp_t gfp_mask, int type,
471                const char *fmt, ...)
472 { }
473 static inline struct audit_buffer *audit_log_start(struct audit_context *ctx,
474                                                    gfp_t gfp_mask, int type)
475 {
476         return NULL;
477 }
478 static inline __printf(2, 3)
479 void audit_log_format(struct audit_buffer *ab, const char *fmt, ...)
480 { }
481 static inline void audit_log_end(struct audit_buffer *ab)
482 { }
483 static inline void audit_log_n_hex(struct audit_buffer *ab,
484                                    const unsigned char *buf, size_t len)
485 { }
486 static inline void audit_log_n_string(struct audit_buffer *ab,
487                                       const char *buf, size_t n)
488 { }
489 static inline void  audit_log_n_untrustedstring(struct audit_buffer *ab,
490                                                 const char *string, size_t n)
491 { }
492 static inline void audit_log_untrustedstring(struct audit_buffer *ab,
493                                              const char *string)
494 { }
495 static inline void audit_log_d_path(struct audit_buffer *ab,
496                                     const char *prefix,
497                                     const struct path *path)
498 { }
499 static inline void audit_log_key(struct audit_buffer *ab, char *key)
500 { }
501 static inline void audit_log_link_denied(const char *string,
502                                          const struct path *link)
503 { }
504 static inline void audit_log_secctx(struct audit_buffer *ab, u32 secid)
505 { }
506 static inline int audit_log_task_context(struct audit_buffer *ab)
507 {
508         return 0;
509 }
510 static inline void audit_log_task_info(struct audit_buffer *ab,
511                                        struct task_struct *tsk)
512 { }
513 #define audit_enabled 0
514 #endif /* CONFIG_AUDIT */
515 static inline void audit_log_string(struct audit_buffer *ab, const char *buf)
516 {
517         audit_log_n_string(ab, buf, strlen(buf));
518 }
519
520 #endif