Branch data Line data Source code
1 : : /* auditsc.c -- System-call auditing support
2 : : * Handles all system-call specific auditing features.
3 : : *
4 : : * Copyright 2003-2004 Red Hat Inc., Durham, North Carolina.
5 : : * Copyright 2005 Hewlett-Packard Development Company, L.P.
6 : : * Copyright (C) 2005, 2006 IBM Corporation
7 : : * All Rights Reserved.
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 as published by
11 : : * the Free Software Foundation; either version 2 of the License, or
12 : : * (at your option) any later version.
13 : : *
14 : : * This program is distributed in the hope that it will be useful,
15 : : * but WITHOUT ANY WARRANTY; without even the implied warranty of
16 : : * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 : : * GNU General Public License for more details.
18 : : *
19 : : * You should have received a copy of the GNU General Public License
20 : : * along with this program; if not, write to the Free Software
21 : : * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
22 : : *
23 : : * Written by Rickard E. (Rik) Faith <faith@redhat.com>
24 : : *
25 : : * Many of the ideas implemented here are from Stephen C. Tweedie,
26 : : * especially the idea of avoiding a copy by using getname.
27 : : *
28 : : * The method for actual interception of syscall entry and exit (not in
29 : : * this file -- see entry.S) is based on a GPL'd patch written by
30 : : * okir@suse.de and Copyright 2003 SuSE Linux AG.
31 : : *
32 : : * POSIX message queue support added by George Wilson <ltcgcw@us.ibm.com>,
33 : : * 2006.
34 : : *
35 : : * The support of additional filter rules compares (>, <, >=, <=) was
36 : : * added by Dustin Kirkland <dustin.kirkland@us.ibm.com>, 2005.
37 : : *
38 : : * Modified by Amy Griffis <amy.griffis@hp.com> to collect additional
39 : : * filesystem information.
40 : : *
41 : : * Subject and object context labeling support added by <danjones@us.ibm.com>
42 : : * and <dustin.kirkland@us.ibm.com> for LSPP certification compliance.
43 : : */
44 : :
45 : : #include <linux/init.h>
46 : : #include <asm/types.h>
47 : : #include <linux/atomic.h>
48 : : #include <linux/fs.h>
49 : : #include <linux/namei.h>
50 : : #include <linux/mm.h>
51 : : #include <linux/export.h>
52 : : #include <linux/slab.h>
53 : : #include <linux/mount.h>
54 : : #include <linux/socket.h>
55 : : #include <linux/mqueue.h>
56 : : #include <linux/audit.h>
57 : : #include <linux/personality.h>
58 : : #include <linux/time.h>
59 : : #include <linux/netlink.h>
60 : : #include <linux/compiler.h>
61 : : #include <asm/unistd.h>
62 : : #include <linux/security.h>
63 : : #include <linux/list.h>
64 : : #include <linux/tty.h>
65 : : #include <linux/binfmts.h>
66 : : #include <linux/highmem.h>
67 : : #include <linux/syscalls.h>
68 : : #include <linux/capability.h>
69 : : #include <linux/fs_struct.h>
70 : : #include <linux/compat.h>
71 : :
72 : : #include "audit.h"
73 : :
74 : : /* flags stating the success for a syscall */
75 : : #define AUDITSC_INVALID 0
76 : : #define AUDITSC_SUCCESS 1
77 : : #define AUDITSC_FAILURE 2
78 : :
79 : : /* no execve audit message should be longer than this (userspace limits) */
80 : : #define MAX_EXECVE_AUDIT_LEN 7500
81 : :
82 : : /* number of audit rules */
83 : : int audit_n_rules;
84 : :
85 : : /* determines whether we collect data for signals sent */
86 : : int audit_signals;
87 : :
88 : : struct audit_aux_data {
89 : : struct audit_aux_data *next;
90 : : int type;
91 : : };
92 : :
93 : : #define AUDIT_AUX_IPCPERM 0
94 : :
95 : : /* Number of target pids per aux struct. */
96 : : #define AUDIT_AUX_PIDS 16
97 : :
98 : : struct audit_aux_data_pids {
99 : : struct audit_aux_data d;
100 : : pid_t target_pid[AUDIT_AUX_PIDS];
101 : : kuid_t target_auid[AUDIT_AUX_PIDS];
102 : : kuid_t target_uid[AUDIT_AUX_PIDS];
103 : : unsigned int target_sessionid[AUDIT_AUX_PIDS];
104 : : u32 target_sid[AUDIT_AUX_PIDS];
105 : : char target_comm[AUDIT_AUX_PIDS][TASK_COMM_LEN];
106 : : int pid_count;
107 : : };
108 : :
109 : : struct audit_aux_data_bprm_fcaps {
110 : : struct audit_aux_data d;
111 : : struct audit_cap_data fcap;
112 : : unsigned int fcap_ver;
113 : : struct audit_cap_data old_pcap;
114 : : struct audit_cap_data new_pcap;
115 : : };
116 : :
117 : : struct audit_tree_refs {
118 : : struct audit_tree_refs *next;
119 : : struct audit_chunk *c[31];
120 : : };
121 : :
122 : : static inline int open_arg(int flags, int mask)
123 : : {
124 : : int n = ACC_MODE(flags);
125 : : if (flags & (O_TRUNC | O_CREAT))
126 : : n |= AUDIT_PERM_WRITE;
127 : : return n & mask;
128 : : }
129 : :
130 : 0 : static int audit_match_perm(struct audit_context *ctx, int mask)
131 : : {
132 : : unsigned n;
133 [ # # ]: 0 : if (unlikely(!ctx))
134 : : return 0;
135 : 0 : n = ctx->major;
136 : :
137 [ # # # # : 0 : switch (audit_classify_syscall(ctx->arch, n)) {
# # # ]
138 : : case 0: /* native */
139 [ # # # # ]: 0 : if ((mask & AUDIT_PERM_WRITE) &&
140 : 0 : audit_match_class(AUDIT_CLASS_WRITE, n))
141 : : return 1;
142 [ # # # # ]: 0 : if ((mask & AUDIT_PERM_READ) &&
143 : 0 : audit_match_class(AUDIT_CLASS_READ, n))
144 : : return 1;
145 [ # # # # ]: 0 : if ((mask & AUDIT_PERM_ATTR) &&
146 : 0 : audit_match_class(AUDIT_CLASS_CHATTR, n))
147 : : return 1;
148 : : return 0;
149 : : case 1: /* 32bit on biarch */
150 [ # # # # ]: 0 : if ((mask & AUDIT_PERM_WRITE) &&
151 : 0 : audit_match_class(AUDIT_CLASS_WRITE_32, n))
152 : : return 1;
153 [ # # # # ]: 0 : if ((mask & AUDIT_PERM_READ) &&
154 : 0 : audit_match_class(AUDIT_CLASS_READ_32, n))
155 : : return 1;
156 [ # # # # ]: 0 : if ((mask & AUDIT_PERM_ATTR) &&
157 : 0 : audit_match_class(AUDIT_CLASS_CHATTR_32, n))
158 : : return 1;
159 : : return 0;
160 : : case 2: /* open */
161 : 0 : return mask & ACC_MODE(ctx->argv[1]);
162 : : case 3: /* openat */
163 : 0 : return mask & ACC_MODE(ctx->argv[2]);
164 : : case 4: /* socketcall */
165 [ # # ][ # # ]: 0 : return ((mask & AUDIT_PERM_WRITE) && ctx->argv[0] == SYS_BIND);
166 : : case 5: /* execve */
167 : 0 : return mask & AUDIT_PERM_EXEC;
168 : : default:
169 : : return 0;
170 : : }
171 : : }
172 : :
173 : : static int audit_match_filetype(struct audit_context *ctx, int val)
174 : : {
175 : : struct audit_names *n;
176 : : umode_t mode = (umode_t)val;
177 : :
178 [ # # ]: 0 : if (unlikely(!ctx))
179 : : return 0;
180 : :
181 [ # # ]: 0 : list_for_each_entry(n, &ctx->names_list, list) {
182 [ # # ][ # # ]: 0 : if ((n->ino != -1) &&
183 : 0 : ((n->mode & S_IFMT) == mode))
184 : : return 1;
185 : : }
186 : :
187 : : return 0;
188 : : }
189 : :
190 : : /*
191 : : * We keep a linked list of fixed-sized (31 pointer) arrays of audit_chunk *;
192 : : * ->first_trees points to its beginning, ->trees - to the current end of data.
193 : : * ->tree_count is the number of free entries in array pointed to by ->trees.
194 : : * Original condition is (NULL, NULL, 0); as soon as it grows we never revert to NULL,
195 : : * "empty" becomes (p, p, 31) afterwards. We don't shrink the list (and seriously,
196 : : * it's going to remain 1-element for almost any setup) until we free context itself.
197 : : * References in it _are_ dropped - at the same time we free/drop aux stuff.
198 : : */
199 : :
200 : : #ifdef CONFIG_AUDIT_TREE
201 : 0 : static void audit_set_auditable(struct audit_context *ctx)
202 : : {
203 [ # # # # ]: 0 : if (!ctx->prio) {
204 : 0 : ctx->prio = 1;
205 : 0 : ctx->current_state = AUDIT_RECORD_CONTEXT;
206 : : }
207 : 0 : }
208 : :
209 : 0 : static int put_tree_ref(struct audit_context *ctx, struct audit_chunk *chunk)
210 : : {
211 : 0 : struct audit_tree_refs *p = ctx->trees;
212 : 0 : int left = ctx->tree_count;
213 [ # # ][ # # ]: 0 : if (likely(left)) {
214 : 0 : p->c[--left] = chunk;
215 : 0 : ctx->tree_count = left;
216 : : return 1;
217 : : }
218 [ # # ][ # # ]: 0 : if (!p)
219 : : return 0;
220 : 0 : p = p->next;
221 [ # # ][ # # ]: 0 : if (p) {
222 : 0 : p->c[30] = chunk;
223 : 0 : ctx->trees = p;
224 : 0 : ctx->tree_count = 30;
225 : : return 1;
226 : : }
227 : : return 0;
228 : : }
229 : :
230 : 0 : static int grow_tree_refs(struct audit_context *ctx)
231 : : {
232 : 0 : struct audit_tree_refs *p = ctx->trees;
233 : 0 : ctx->trees = kzalloc(sizeof(struct audit_tree_refs), GFP_KERNEL);
234 [ # # ]: 0 : if (!ctx->trees) {
235 : 0 : ctx->trees = p;
236 : 0 : return 0;
237 : : }
238 [ # # ]: 0 : if (p)
239 : 0 : p->next = ctx->trees;
240 : : else
241 : 0 : ctx->first_trees = ctx->trees;
242 : 0 : ctx->tree_count = 31;
243 : 0 : return 1;
244 : : }
245 : : #endif
246 : :
247 : 0 : static void unroll_tree_refs(struct audit_context *ctx,
248 : : struct audit_tree_refs *p, int count)
249 : : {
250 : : #ifdef CONFIG_AUDIT_TREE
251 : : struct audit_tree_refs *q;
252 : : int n;
253 [ # # ]: 0 : if (!p) {
254 : : /* we started with empty chain */
255 : 0 : p = ctx->first_trees;
256 : : count = 31;
257 : : /* if the very first allocation has failed, nothing to do */
258 [ # # ]: 0 : if (!p)
259 : 0 : return;
260 : : }
261 : : n = count;
262 [ # # ]: 0 : for (q = p; q != ctx->trees; q = q->next, n = 31) {
263 [ # # ]: 0 : while (n--) {
264 : 0 : audit_put_chunk(q->c[n]);
265 : 0 : q->c[n] = NULL;
266 : : }
267 : : }
268 [ # # ]: 0 : while (n-- > ctx->tree_count) {
269 : 0 : audit_put_chunk(q->c[n]);
270 : 0 : q->c[n] = NULL;
271 : : }
272 : 0 : ctx->trees = p;
273 : 0 : ctx->tree_count = count;
274 : : #endif
275 : : }
276 : :
277 : 0 : static void free_tree_refs(struct audit_context *ctx)
278 : : {
279 : : struct audit_tree_refs *p, *q;
280 [ # # ]: 0 : for (p = ctx->first_trees; p; p = q) {
281 : 0 : q = p->next;
282 : 0 : kfree(p);
283 : : }
284 : 0 : }
285 : :
286 : 0 : static int match_tree_refs(struct audit_context *ctx, struct audit_tree *tree)
287 : : {
288 : : #ifdef CONFIG_AUDIT_TREE
289 : : struct audit_tree_refs *p;
290 : : int n;
291 [ # # ]: 0 : if (!tree)
292 : : return 0;
293 : : /* full ones */
294 [ # # ]: 0 : for (p = ctx->first_trees; p != ctx->trees; p = p->next) {
295 [ # # ]: 0 : for (n = 0; n < 31; n++)
296 [ # # ]: 0 : if (audit_tree_match(p->c[n], tree))
297 : : return 1;
298 : : }
299 : : /* partial */
300 [ # # ]: 0 : if (p) {
301 [ # # ]: 0 : for (n = ctx->tree_count; n < 31; n++)
302 [ # # ]: 0 : if (audit_tree_match(p->c[n], tree))
303 : : return 1;
304 : : }
305 : : #endif
306 : : return 0;
307 : : }
308 : :
309 : 0 : static int audit_compare_uid(kuid_t uid,
310 : : struct audit_names *name,
311 : : struct audit_field *f,
312 : : struct audit_context *ctx)
313 : : {
314 : : struct audit_names *n;
315 : : int rc;
316 : :
317 [ # # ]: 0 : if (name) {
318 : 0 : rc = audit_uid_comparator(uid, f->op, name->uid);
319 [ # # ]: 0 : if (rc)
320 : : return rc;
321 : : }
322 : :
323 [ # # ]: 0 : if (ctx) {
324 [ # # ]: 0 : list_for_each_entry(n, &ctx->names_list, list) {
325 : 0 : rc = audit_uid_comparator(uid, f->op, n->uid);
326 [ # # ]: 0 : if (rc)
327 : : return rc;
328 : : }
329 : : }
330 : : return 0;
331 : : }
332 : :
333 : 0 : static int audit_compare_gid(kgid_t gid,
334 : : struct audit_names *name,
335 : : struct audit_field *f,
336 : : struct audit_context *ctx)
337 : : {
338 : : struct audit_names *n;
339 : : int rc;
340 : :
341 [ # # ]: 0 : if (name) {
342 : 0 : rc = audit_gid_comparator(gid, f->op, name->gid);
343 [ # # ]: 0 : if (rc)
344 : : return rc;
345 : : }
346 : :
347 [ # # ]: 0 : if (ctx) {
348 [ # # ]: 0 : list_for_each_entry(n, &ctx->names_list, list) {
349 : 0 : rc = audit_gid_comparator(gid, f->op, n->gid);
350 [ # # ]: 0 : if (rc)
351 : : return rc;
352 : : }
353 : : }
354 : : return 0;
355 : : }
356 : :
357 : 0 : static int audit_field_compare(struct task_struct *tsk,
358 : : const struct cred *cred,
359 : : struct audit_field *f,
360 : : struct audit_context *ctx,
361 : : struct audit_names *name)
362 : : {
363 [ # # # # : 0 : switch (f->val) {
# # # # #
# # # # #
# # # # #
# # # # #
# # ]
364 : : /* process to file object comparisons */
365 : : case AUDIT_COMPARE_UID_TO_OBJ_UID:
366 : 0 : return audit_compare_uid(cred->uid, name, f, ctx);
367 : : case AUDIT_COMPARE_GID_TO_OBJ_GID:
368 : 0 : return audit_compare_gid(cred->gid, name, f, ctx);
369 : : case AUDIT_COMPARE_EUID_TO_OBJ_UID:
370 : 0 : return audit_compare_uid(cred->euid, name, f, ctx);
371 : : case AUDIT_COMPARE_EGID_TO_OBJ_GID:
372 : 0 : return audit_compare_gid(cred->egid, name, f, ctx);
373 : : case AUDIT_COMPARE_AUID_TO_OBJ_UID:
374 : 0 : return audit_compare_uid(tsk->loginuid, name, f, ctx);
375 : : case AUDIT_COMPARE_SUID_TO_OBJ_UID:
376 : 0 : return audit_compare_uid(cred->suid, name, f, ctx);
377 : : case AUDIT_COMPARE_SGID_TO_OBJ_GID:
378 : 0 : return audit_compare_gid(cred->sgid, name, f, ctx);
379 : : case AUDIT_COMPARE_FSUID_TO_OBJ_UID:
380 : 0 : return audit_compare_uid(cred->fsuid, name, f, ctx);
381 : : case AUDIT_COMPARE_FSGID_TO_OBJ_GID:
382 : 0 : return audit_compare_gid(cred->fsgid, name, f, ctx);
383 : : /* uid comparisons */
384 : : case AUDIT_COMPARE_UID_TO_AUID:
385 : 0 : return audit_uid_comparator(cred->uid, f->op, tsk->loginuid);
386 : : case AUDIT_COMPARE_UID_TO_EUID:
387 : 0 : return audit_uid_comparator(cred->uid, f->op, cred->euid);
388 : : case AUDIT_COMPARE_UID_TO_SUID:
389 : 0 : return audit_uid_comparator(cred->uid, f->op, cred->suid);
390 : : case AUDIT_COMPARE_UID_TO_FSUID:
391 : 0 : return audit_uid_comparator(cred->uid, f->op, cred->fsuid);
392 : : /* auid comparisons */
393 : : case AUDIT_COMPARE_AUID_TO_EUID:
394 : 0 : return audit_uid_comparator(tsk->loginuid, f->op, cred->euid);
395 : : case AUDIT_COMPARE_AUID_TO_SUID:
396 : 0 : return audit_uid_comparator(tsk->loginuid, f->op, cred->suid);
397 : : case AUDIT_COMPARE_AUID_TO_FSUID:
398 : 0 : return audit_uid_comparator(tsk->loginuid, f->op, cred->fsuid);
399 : : /* euid comparisons */
400 : : case AUDIT_COMPARE_EUID_TO_SUID:
401 : 0 : return audit_uid_comparator(cred->euid, f->op, cred->suid);
402 : : case AUDIT_COMPARE_EUID_TO_FSUID:
403 : 0 : return audit_uid_comparator(cred->euid, f->op, cred->fsuid);
404 : : /* suid comparisons */
405 : : case AUDIT_COMPARE_SUID_TO_FSUID:
406 : 0 : return audit_uid_comparator(cred->suid, f->op, cred->fsuid);
407 : : /* gid comparisons */
408 : : case AUDIT_COMPARE_GID_TO_EGID:
409 : 0 : return audit_gid_comparator(cred->gid, f->op, cred->egid);
410 : : case AUDIT_COMPARE_GID_TO_SGID:
411 : 0 : return audit_gid_comparator(cred->gid, f->op, cred->sgid);
412 : : case AUDIT_COMPARE_GID_TO_FSGID:
413 : 0 : return audit_gid_comparator(cred->gid, f->op, cred->fsgid);
414 : : /* egid comparisons */
415 : : case AUDIT_COMPARE_EGID_TO_SGID:
416 : 0 : return audit_gid_comparator(cred->egid, f->op, cred->sgid);
417 : : case AUDIT_COMPARE_EGID_TO_FSGID:
418 : 0 : return audit_gid_comparator(cred->egid, f->op, cred->fsgid);
419 : : /* sgid comparison */
420 : : case AUDIT_COMPARE_SGID_TO_FSGID:
421 : 0 : return audit_gid_comparator(cred->sgid, f->op, cred->fsgid);
422 : : default:
423 : 0 : WARN(1, "Missing AUDIT_COMPARE define. Report as a bug\n");
424 : 0 : return 0;
425 : : }
426 : : return 0;
427 : : }
428 : :
429 : : /* Determine if any context name data matches a rule's watch data */
430 : : /* Compare a task_struct with an audit_rule. Return 1 on match, 0
431 : : * otherwise.
432 : : *
433 : : * If task_creation is true, this is an explicit indication that we are
434 : : * filtering a task rule at task creation time. This and tsk == current are
435 : : * the only situations where tsk->cred may be accessed without an rcu read lock.
436 : : */
437 : 0 : static int audit_filter_rules(struct task_struct *tsk,
438 : : struct audit_krule *rule,
439 : : struct audit_context *ctx,
440 : : struct audit_names *name,
441 : : enum audit_state *state,
442 : : bool task_creation)
443 : : {
444 : : const struct cred *cred;
445 : : int i, need_sid = 1;
446 : : u32 sid;
447 : :
448 : 0 : cred = rcu_dereference_check(tsk->cred, tsk == current || task_creation);
449 : :
450 [ # # ]: 0 : for (i = 0; i < rule->field_count; i++) {
451 : 0 : struct audit_field *f = &rule->fields[i];
452 : : struct audit_names *n;
453 : : int result = 0;
454 : :
455 [ # # # # : 0 : switch (f->type) {
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # ]
456 : : case AUDIT_PID:
457 : 0 : result = audit_comparator(tsk->pid, f->op, f->val);
458 : : break;
459 : : case AUDIT_PPID:
460 [ # # ]: 0 : if (ctx) {
461 [ # # ]: 0 : if (!ctx->ppid)
462 : 0 : ctx->ppid = sys_getppid();
463 : 0 : result = audit_comparator(ctx->ppid, f->op, f->val);
464 : : }
465 : : break;
466 : : case AUDIT_UID:
467 : 0 : result = audit_uid_comparator(cred->uid, f->op, f->uid);
468 : : break;
469 : : case AUDIT_EUID:
470 : 0 : result = audit_uid_comparator(cred->euid, f->op, f->uid);
471 : : break;
472 : : case AUDIT_SUID:
473 : 0 : result = audit_uid_comparator(cred->suid, f->op, f->uid);
474 : : break;
475 : : case AUDIT_FSUID:
476 : 0 : result = audit_uid_comparator(cred->fsuid, f->op, f->uid);
477 : : break;
478 : : case AUDIT_GID:
479 : 0 : result = audit_gid_comparator(cred->gid, f->op, f->gid);
480 [ # # ]: 0 : if (f->op == Audit_equal) {
481 [ # # ]: 0 : if (!result)
482 : 0 : result = in_group_p(f->gid);
483 [ # # ]: 0 : } else if (f->op == Audit_not_equal) {
484 [ # # ]: 0 : if (result)
485 : 0 : result = !in_group_p(f->gid);
486 : : }
487 : : break;
488 : : case AUDIT_EGID:
489 : 0 : result = audit_gid_comparator(cred->egid, f->op, f->gid);
490 [ # # ]: 0 : if (f->op == Audit_equal) {
491 [ # # ]: 0 : if (!result)
492 : 0 : result = in_egroup_p(f->gid);
493 [ # # ]: 0 : } else if (f->op == Audit_not_equal) {
494 [ # # ]: 0 : if (result)
495 : 0 : result = !in_egroup_p(f->gid);
496 : : }
497 : : break;
498 : : case AUDIT_SGID:
499 : 0 : result = audit_gid_comparator(cred->sgid, f->op, f->gid);
500 : : break;
501 : : case AUDIT_FSGID:
502 : 0 : result = audit_gid_comparator(cred->fsgid, f->op, f->gid);
503 : : break;
504 : : case AUDIT_PERS:
505 : 0 : result = audit_comparator(tsk->personality, f->op, f->val);
506 : : break;
507 : : case AUDIT_ARCH:
508 [ # # ]: 0 : if (ctx)
509 : 0 : result = audit_comparator(ctx->arch, f->op, f->val);
510 : : break;
511 : :
512 : : case AUDIT_EXIT:
513 [ # # ][ # # ]: 0 : if (ctx && ctx->return_valid)
514 : 0 : result = audit_comparator(ctx->return_code, f->op, f->val);
515 : : break;
516 : : case AUDIT_SUCCESS:
517 [ # # ][ # # ]: 0 : if (ctx && ctx->return_valid) {
518 [ # # ]: 0 : if (f->val)
519 : 0 : result = audit_comparator(ctx->return_valid, f->op, AUDITSC_SUCCESS);
520 : : else
521 : 0 : result = audit_comparator(ctx->return_valid, f->op, AUDITSC_FAILURE);
522 : : }
523 : : break;
524 : : case AUDIT_DEVMAJOR:
525 [ # # ]: 0 : if (name) {
526 [ # # # # ]: 0 : if (audit_comparator(MAJOR(name->dev), f->op, f->val) ||
527 : 0 : audit_comparator(MAJOR(name->rdev), f->op, f->val))
528 : : ++result;
529 [ # # ]: 0 : } else if (ctx) {
530 [ # # ]: 0 : list_for_each_entry(n, &ctx->names_list, list) {
531 [ # # # # ]: 0 : if (audit_comparator(MAJOR(n->dev), f->op, f->val) ||
532 : 0 : audit_comparator(MAJOR(n->rdev), f->op, f->val)) {
533 : : ++result;
534 : : break;
535 : : }
536 : : }
537 : : }
538 : : break;
539 : : case AUDIT_DEVMINOR:
540 [ # # ]: 0 : if (name) {
541 [ # # # # ]: 0 : if (audit_comparator(MINOR(name->dev), f->op, f->val) ||
542 : 0 : audit_comparator(MINOR(name->rdev), f->op, f->val))
543 : : ++result;
544 [ # # ]: 0 : } else if (ctx) {
545 [ # # ]: 0 : list_for_each_entry(n, &ctx->names_list, list) {
546 [ # # # # ]: 0 : if (audit_comparator(MINOR(n->dev), f->op, f->val) ||
547 : 0 : audit_comparator(MINOR(n->rdev), f->op, f->val)) {
548 : : ++result;
549 : : break;
550 : : }
551 : : }
552 : : }
553 : : break;
554 : : case AUDIT_INODE:
555 [ # # ]: 0 : if (name)
556 : 0 : result = audit_comparator(name->ino, f->op, f->val);
557 [ # # ]: 0 : else if (ctx) {
558 [ # # ]: 0 : list_for_each_entry(n, &ctx->names_list, list) {
559 [ # # ]: 0 : if (audit_comparator(n->ino, f->op, f->val)) {
560 : : ++result;
561 : : break;
562 : : }
563 : : }
564 : : }
565 : : break;
566 : : case AUDIT_OBJ_UID:
567 [ # # ]: 0 : if (name) {
568 : 0 : result = audit_uid_comparator(name->uid, f->op, f->uid);
569 [ # # ]: 0 : } else if (ctx) {
570 [ # # ]: 0 : list_for_each_entry(n, &ctx->names_list, list) {
571 [ # # ]: 0 : if (audit_uid_comparator(n->uid, f->op, f->uid)) {
572 : : ++result;
573 : : break;
574 : : }
575 : : }
576 : : }
577 : : break;
578 : : case AUDIT_OBJ_GID:
579 [ # # ]: 0 : if (name) {
580 : 0 : result = audit_gid_comparator(name->gid, f->op, f->gid);
581 [ # # ]: 0 : } else if (ctx) {
582 [ # # ]: 0 : list_for_each_entry(n, &ctx->names_list, list) {
583 [ # # ]: 0 : if (audit_gid_comparator(n->gid, f->op, f->gid)) {
584 : : ++result;
585 : : break;
586 : : }
587 : : }
588 : : }
589 : : break;
590 : : case AUDIT_WATCH:
591 [ # # ]: 0 : if (name)
592 : 0 : result = audit_watch_compare(rule->watch, name->ino, name->dev);
593 : : break;
594 : : case AUDIT_DIR:
595 [ # # ]: 0 : if (ctx)
596 : 0 : result = match_tree_refs(ctx, rule->tree);
597 : : break;
598 : : case AUDIT_LOGINUID:
599 : : result = 0;
600 [ # # ]: 0 : if (ctx)
601 : 0 : result = audit_uid_comparator(tsk->loginuid, f->op, f->uid);
602 : : break;
603 : : case AUDIT_LOGINUID_SET:
604 : 0 : result = audit_comparator(audit_loginuid_set(tsk), f->op, f->val);
605 : : break;
606 : : case AUDIT_SUBJ_USER:
607 : : case AUDIT_SUBJ_ROLE:
608 : : case AUDIT_SUBJ_TYPE:
609 : : case AUDIT_SUBJ_SEN:
610 : : case AUDIT_SUBJ_CLR:
611 : : /* NOTE: this may return negative values indicating
612 : : a temporary error. We simply treat this as a
613 : : match for now to avoid losing information that
614 : : may be wanted. An error message will also be
615 : : logged upon error */
616 [ # # ]: 0 : if (f->lsm_rule) {
617 [ # # ]: 0 : if (need_sid) {
618 : 0 : security_task_getsecid(tsk, &sid);
619 : : need_sid = 0;
620 : : }
621 : 0 : result = security_audit_rule_match(sid, f->type,
622 : : f->op,
623 : : f->lsm_rule,
624 : : ctx);
625 : : }
626 : : break;
627 : : case AUDIT_OBJ_USER:
628 : : case AUDIT_OBJ_ROLE:
629 : : case AUDIT_OBJ_TYPE:
630 : : case AUDIT_OBJ_LEV_LOW:
631 : : case AUDIT_OBJ_LEV_HIGH:
632 : : /* The above note for AUDIT_SUBJ_USER...AUDIT_SUBJ_CLR
633 : : also applies here */
634 [ # # ]: 0 : if (f->lsm_rule) {
635 : : /* Find files that match */
636 [ # # ]: 0 : if (name) {
637 : 0 : result = security_audit_rule_match(
638 : : name->osid, f->type, f->op,
639 : : f->lsm_rule, ctx);
640 [ # # ]: 0 : } else if (ctx) {
641 [ # # ]: 0 : list_for_each_entry(n, &ctx->names_list, list) {
642 [ # # ]: 0 : if (security_audit_rule_match(n->osid, f->type,
643 : : f->op, f->lsm_rule,
644 : : ctx)) {
645 : : ++result;
646 : : break;
647 : : }
648 : : }
649 : : }
650 : : /* Find ipc objects that match */
651 [ # # ][ # # ]: 0 : if (!ctx || ctx->type != AUDIT_IPC)
652 : : break;
653 [ # # ]: 0 : if (security_audit_rule_match(ctx->ipc.osid,
654 : : f->type, f->op,
655 : : f->lsm_rule, ctx))
656 : 0 : ++result;
657 : : }
658 : : break;
659 : : case AUDIT_ARG0:
660 : : case AUDIT_ARG1:
661 : : case AUDIT_ARG2:
662 : : case AUDIT_ARG3:
663 [ # # ]: 0 : if (ctx)
664 : 0 : result = audit_comparator(ctx->argv[f->type-AUDIT_ARG0], f->op, f->val);
665 : : break;
666 : : case AUDIT_FILTERKEY:
667 : : /* ignore this field for filtering */
668 : : result = 1;
669 : : break;
670 : : case AUDIT_PERM:
671 : 0 : result = audit_match_perm(ctx, f->val);
672 : : break;
673 : : case AUDIT_FILETYPE:
674 : 0 : result = audit_match_filetype(ctx, f->val);
675 : : break;
676 : : case AUDIT_FIELD_COMPARE:
677 : 0 : result = audit_field_compare(tsk, cred, f, ctx, name);
678 : : break;
679 : : }
680 [ # # ]: 0 : if (!result)
681 : : return 0;
682 : : }
683 : :
684 [ # # ]: 0 : if (ctx) {
685 [ # # ]: 0 : if (rule->prio <= ctx->prio)
686 : : return 0;
687 [ # # ]: 0 : if (rule->filterkey) {
688 : 0 : kfree(ctx->filterkey);
689 : 0 : ctx->filterkey = kstrdup(rule->filterkey, GFP_ATOMIC);
690 : : }
691 : 0 : ctx->prio = rule->prio;
692 : : }
693 [ # # # ]: 0 : switch (rule->action) {
694 : 0 : case AUDIT_NEVER: *state = AUDIT_DISABLED; break;
695 : 0 : case AUDIT_ALWAYS: *state = AUDIT_RECORD_CONTEXT; break;
696 : : }
697 : : return 1;
698 : : }
699 : :
700 : : /* At process creation time, we can determine if system-call auditing is
701 : : * completely disabled for this task. Since we only have the task
702 : : * structure at this point, we can only check uid and gid.
703 : : */
704 : 0 : static enum audit_state audit_filter_task(struct task_struct *tsk, char **key)
705 : : {
706 : : struct audit_entry *e;
707 : : enum audit_state state;
708 : :
709 : : rcu_read_lock();
710 [ # # ]: 0 : list_for_each_entry_rcu(e, &audit_filter_list[AUDIT_FILTER_TASK], list) {
711 [ # # ]: 0 : if (audit_filter_rules(tsk, &e->rule, NULL, NULL,
712 : : &state, true)) {
713 [ # # ]: 0 : if (state == AUDIT_RECORD_CONTEXT)
714 : 0 : *key = kstrdup(e->rule.filterkey, GFP_ATOMIC);
715 : : rcu_read_unlock();
716 : 0 : return state;
717 : : }
718 : : }
719 : : rcu_read_unlock();
720 : 0 : return AUDIT_BUILD_CONTEXT;
721 : : }
722 : :
723 : : /* At syscall entry and exit time, this filter is called if the
724 : : * audit_state is not low enough that auditing cannot take place, but is
725 : : * also not high enough that we already know we have to write an audit
726 : : * record (i.e., the state is AUDIT_SETUP_CONTEXT or AUDIT_BUILD_CONTEXT).
727 : : */
728 : 0 : static enum audit_state audit_filter_syscall(struct task_struct *tsk,
729 : : struct audit_context *ctx,
730 : : struct list_head *list)
731 : : {
732 : : struct audit_entry *e;
733 : : enum audit_state state;
734 : :
735 [ # # ][ # # ]: 0 : if (audit_pid && tsk->tgid == audit_pid)
736 : : return AUDIT_DISABLED;
737 : :
738 : : rcu_read_lock();
739 [ # # ]: 0 : if (!list_empty(list)) {
740 : 0 : int word = AUDIT_WORD(ctx->major);
741 : 0 : int bit = AUDIT_BIT(ctx->major);
742 : :
743 [ # # ]: 0 : list_for_each_entry_rcu(e, list, list) {
744 [ # # # # ]: 0 : if ((e->rule.mask[word] & bit) == bit &&
745 : 0 : audit_filter_rules(tsk, &e->rule, ctx, NULL,
746 : : &state, false)) {
747 : : rcu_read_unlock();
748 : 0 : ctx->current_state = state;
749 : 0 : return state;
750 : : }
751 : : }
752 : : }
753 : : rcu_read_unlock();
754 : 0 : return AUDIT_BUILD_CONTEXT;
755 : : }
756 : :
757 : : /*
758 : : * Given an audit_name check the inode hash table to see if they match.
759 : : * Called holding the rcu read lock to protect the use of audit_inode_hash
760 : : */
761 : 0 : static int audit_filter_inode_name(struct task_struct *tsk,
762 : : struct audit_names *n,
763 : : struct audit_context *ctx) {
764 : : int word, bit;
765 : 0 : int h = audit_hash_ino((u32)n->ino);
766 : 0 : struct list_head *list = &audit_inode_hash[h];
767 : : struct audit_entry *e;
768 : : enum audit_state state;
769 : :
770 : 0 : word = AUDIT_WORD(ctx->major);
771 : 0 : bit = AUDIT_BIT(ctx->major);
772 : :
773 [ # # ]: 0 : if (list_empty(list))
774 : : return 0;
775 : :
776 [ # # ]: 0 : list_for_each_entry_rcu(e, list, list) {
777 [ # # # # ]: 0 : if ((e->rule.mask[word] & bit) == bit &&
778 : 0 : audit_filter_rules(tsk, &e->rule, ctx, n, &state, false)) {
779 : 0 : ctx->current_state = state;
780 : 0 : return 1;
781 : : }
782 : : }
783 : :
784 : : return 0;
785 : : }
786 : :
787 : : /* At syscall exit time, this filter is called if any audit_names have been
788 : : * collected during syscall processing. We only check rules in sublists at hash
789 : : * buckets applicable to the inode numbers in audit_names.
790 : : * Regarding audit_state, same rules apply as for audit_filter_syscall().
791 : : */
792 : 0 : void audit_filter_inodes(struct task_struct *tsk, struct audit_context *ctx)
793 : : {
794 : : struct audit_names *n;
795 : :
796 [ # # ][ # # ]: 0 : if (audit_pid && tsk->tgid == audit_pid)
797 : 0 : return;
798 : :
799 : : rcu_read_lock();
800 : :
801 [ # # ]: 0 : list_for_each_entry(n, &ctx->names_list, list) {
802 [ # # ]: 0 : if (audit_filter_inode_name(tsk, n, ctx))
803 : : break;
804 : : }
805 : : rcu_read_unlock();
806 : : }
807 : :
808 : : static inline struct audit_context *audit_get_context(struct task_struct *tsk,
809 : : int return_valid,
810 : : long return_code)
811 : : {
812 : 0 : struct audit_context *context = tsk->audit_context;
813 : :
814 [ # # ][ # # ]: 0 : if (!context)
815 : : return NULL;
816 : 0 : context->return_valid = return_valid;
817 : :
818 : : /*
819 : : * we need to fix up the return code in the audit logs if the actual
820 : : * return codes are later going to be fixed up by the arch specific
821 : : * signal handlers
822 : : *
823 : : * This is actually a test for:
824 : : * (rc == ERESTARTSYS ) || (rc == ERESTARTNOINTR) ||
825 : : * (rc == ERESTARTNOHAND) || (rc == ERESTART_RESTARTBLOCK)
826 : : *
827 : : * but is faster than a bunch of ||
828 : : */
829 [ # # ]: 0 : if (unlikely(return_code <= -ERESTARTSYS) &&
830 [ # # ]: 0 : (return_code >= -ERESTART_RESTARTBLOCK) &&
831 : 0 : (return_code != -ENOIOCTLCMD))
832 : 0 : context->return_code = -EINTR;
833 : : else
834 : 0 : context->return_code = return_code;
835 : :
836 [ # # ][ # # ]: 0 : if (context->in_syscall && !context->dummy) {
[ # # ][ # # ]
837 : 0 : audit_filter_syscall(tsk, context, &audit_filter_list[AUDIT_FILTER_EXIT]);
838 : 0 : audit_filter_inodes(tsk, context);
839 : : }
840 : :
841 : 0 : tsk->audit_context = NULL;
842 : : return context;
843 : : }
844 : :
845 : : static inline void audit_free_names(struct audit_context *context)
846 : : {
847 : : struct audit_names *n, *next;
848 : :
849 : : #if AUDIT_DEBUG == 2
850 : : if (context->put_count + context->ino_count != context->name_count) {
851 : : int i = 0;
852 : :
853 : : printk(KERN_ERR "%s:%d(:%d): major=%d in_syscall=%d"
854 : : " name_count=%d put_count=%d"
855 : : " ino_count=%d [NOT freeing]\n",
856 : : __FILE__, __LINE__,
857 : : context->serial, context->major, context->in_syscall,
858 : : context->name_count, context->put_count,
859 : : context->ino_count);
860 : : list_for_each_entry(n, &context->names_list, list) {
861 : : printk(KERN_ERR "names[%d] = %p = %s\n", i++,
862 : : n->name, n->name->name ?: "(null)");
863 : : }
864 : : dump_stack();
865 : : return;
866 : : }
867 : : #endif
868 : : #if AUDIT_DEBUG
869 : : context->put_count = 0;
870 : : context->ino_count = 0;
871 : : #endif
872 : :
873 [ # # ][ # # ]: 0 : list_for_each_entry_safe(n, next, &context->names_list, list) {
874 : : list_del(&n->list);
875 [ # # ][ # # ]: 0 : if (n->name && n->name_put)
[ # # ][ # # ]
876 : 0 : final_putname(n->name);
877 [ # # ][ # # ]: 0 : if (n->should_free)
878 : 0 : kfree(n);
879 : : }
880 : 0 : context->name_count = 0;
881 : 0 : path_put(&context->pwd);
882 : 0 : context->pwd.dentry = NULL;
883 : 0 : context->pwd.mnt = NULL;
884 : : }
885 : :
886 : : static inline void audit_free_aux(struct audit_context *context)
887 : : {
888 : : struct audit_aux_data *aux;
889 : :
890 [ # # ][ # # ]: 0 : while ((aux = context->aux)) {
891 : 0 : context->aux = aux->next;
892 : 0 : kfree(aux);
893 : : }
894 [ # # ][ # # ]: 0 : while ((aux = context->aux_pids)) {
895 : 0 : context->aux_pids = aux->next;
896 : 0 : kfree(aux);
897 : : }
898 : : }
899 : :
900 : : static inline struct audit_context *audit_alloc_context(enum audit_state state)
901 : : {
902 : : struct audit_context *context;
903 : :
904 : : context = kzalloc(sizeof(*context), GFP_KERNEL);
905 [ # # ]: 1104215 : if (!context)
906 : : return NULL;
907 : 0 : context->state = state;
908 [ # # ]: 0 : context->prio = state == AUDIT_RECORD_CONTEXT ? ~0ULL : 0;
909 : 0 : INIT_LIST_HEAD(&context->killed_trees);
910 : 0 : INIT_LIST_HEAD(&context->names_list);
911 : : return context;
912 : : }
913 : :
914 : : /**
915 : : * audit_alloc - allocate an audit context block for a task
916 : : * @tsk: task
917 : : *
918 : : * Filter on the task information and allocate a per-task audit context
919 : : * if necessary. Doing so turns on system call auditing for the
920 : : * specified task. This is called from copy_process, so no lock is
921 : : * needed.
922 : : */
923 : 0 : int audit_alloc(struct task_struct *tsk)
924 : : {
925 : : struct audit_context *context;
926 : : enum audit_state state;
927 : 1104215 : char *key = NULL;
928 : :
929 [ - + ]: 1104215 : if (likely(!audit_ever_enabled))
930 : : return 0; /* Return if not auditing. */
931 : :
932 : 0 : state = audit_filter_task(tsk, &key);
933 [ # # ]: 0 : if (state == AUDIT_DISABLED) {
934 : : clear_tsk_thread_flag(tsk, TIF_SYSCALL_AUDIT);
935 : 0 : return 0;
936 : : }
937 : :
938 [ # # ]: 0 : if (!(context = audit_alloc_context(state))) {
939 : 0 : kfree(key);
940 : 0 : audit_log_lost("out of memory in audit_alloc");
941 : 0 : return -ENOMEM;
942 : : }
943 : 0 : context->filterkey = key;
944 : :
945 : 0 : tsk->audit_context = context;
946 : : set_tsk_thread_flag(tsk, TIF_SYSCALL_AUDIT);
947 : 0 : return 0;
948 : : }
949 : :
950 : : static inline void audit_free_context(struct audit_context *context)
951 : : {
952 : : audit_free_names(context);
953 : 0 : unroll_tree_refs(context, NULL, 0);
954 : 0 : free_tree_refs(context);
955 : : audit_free_aux(context);
956 : 0 : kfree(context->filterkey);
957 : 0 : kfree(context->sockaddr);
958 : 0 : kfree(context);
959 : : }
960 : :
961 : 0 : static int audit_log_pid_context(struct audit_context *context, pid_t pid,
962 : : kuid_t auid, kuid_t uid, unsigned int sessionid,
963 : : u32 sid, char *comm)
964 : : {
965 : : struct audit_buffer *ab;
966 : 0 : char *ctx = NULL;
967 : : u32 len;
968 : : int rc = 0;
969 : :
970 : 0 : ab = audit_log_start(context, GFP_KERNEL, AUDIT_OBJ_PID);
971 [ # # ]: 0 : if (!ab)
972 : : return rc;
973 : :
974 : 0 : audit_log_format(ab, "opid=%d oauid=%d ouid=%d oses=%d", pid,
975 : : from_kuid(&init_user_ns, auid),
976 : : from_kuid(&init_user_ns, uid), sessionid);
977 [ # # ]: 0 : if (sid) {
978 [ # # ]: 0 : if (security_secid_to_secctx(sid, &ctx, &len)) {
979 : 0 : audit_log_format(ab, " obj=(none)");
980 : : rc = 1;
981 : : } else {
982 : 0 : audit_log_format(ab, " obj=%s", ctx);
983 : 0 : security_release_secctx(ctx, len);
984 : : }
985 : : }
986 : 0 : audit_log_format(ab, " ocomm=");
987 : 0 : audit_log_untrustedstring(ab, comm);
988 : 0 : audit_log_end(ab);
989 : :
990 : 0 : return rc;
991 : : }
992 : :
993 : : /*
994 : : * to_send and len_sent accounting are very loose estimates. We aren't
995 : : * really worried about a hard cap to MAX_EXECVE_AUDIT_LEN so much as being
996 : : * within about 500 bytes (next page boundary)
997 : : *
998 : : * why snprintf? an int is up to 12 digits long. if we just assumed when
999 : : * logging that a[%d]= was going to be 16 characters long we would be wasting
1000 : : * space in every audit message. In one 7500 byte message we can log up to
1001 : : * about 1000 min size arguments. That comes down to about 50% waste of space
1002 : : * if we didn't do the snprintf to find out how long arg_num_len was.
1003 : : */
1004 : 0 : static int audit_log_single_execve_arg(struct audit_context *context,
1005 : : struct audit_buffer **ab,
1006 : : int arg_num,
1007 : : size_t *len_sent,
1008 : : const char __user *p,
1009 : : char *buf)
1010 : : {
1011 : : char arg_num_len_buf[12];
1012 : : const char __user *tmp_p = p;
1013 : : /* how many digits are in arg_num? 5 is the length of ' a=""' */
1014 : 0 : size_t arg_num_len = snprintf(arg_num_len_buf, 12, "%d", arg_num) + 5;
1015 : : size_t len, len_left, to_send;
1016 : : size_t max_execve_audit_len = MAX_EXECVE_AUDIT_LEN;
1017 : : unsigned int i, has_cntl = 0, too_long = 0;
1018 : : int ret;
1019 : :
1020 : : /* strnlen_user includes the null we don't want to send */
1021 : 0 : len_left = len = strnlen_user(p, MAX_ARG_STRLEN) - 1;
1022 : :
1023 : : /*
1024 : : * We just created this mm, if we can't find the strings
1025 : : * we just copied into it something is _very_ wrong. Similar
1026 : : * for strings that are too long, we should not have created
1027 : : * any.
1028 : : */
1029 [ # # ]: 0 : if (unlikely((len == -1) || len > MAX_ARG_STRLEN - 1)) {
1030 : 0 : WARN_ON(1);
1031 : 0 : send_sig(SIGKILL, current, 0);
1032 : 0 : return -1;
1033 : : }
1034 : :
1035 : : /* walk the whole argument looking for non-ascii chars */
1036 : : do {
1037 [ # # ]: 0 : if (len_left > MAX_EXECVE_AUDIT_LEN)
1038 : : to_send = MAX_EXECVE_AUDIT_LEN;
1039 : : else
1040 : : to_send = len_left;
1041 : : ret = copy_from_user(buf, tmp_p, to_send);
1042 : : /*
1043 : : * There is no reason for this copy to be short. We just
1044 : : * copied them here, and the mm hasn't been exposed to user-
1045 : : * space yet.
1046 : : */
1047 [ # # ]: 0 : if (ret) {
1048 : 0 : WARN_ON(1);
1049 : 0 : send_sig(SIGKILL, current, 0);
1050 : 0 : return -1;
1051 : : }
1052 : 0 : buf[to_send] = '\0';
1053 : 0 : has_cntl = audit_string_contains_control(buf, to_send);
1054 [ # # ]: 0 : if (has_cntl) {
1055 : : /*
1056 : : * hex messages get logged as 2 bytes, so we can only
1057 : : * send half as much in each message
1058 : : */
1059 : : max_execve_audit_len = MAX_EXECVE_AUDIT_LEN / 2;
1060 : : break;
1061 : : }
1062 : 0 : len_left -= to_send;
1063 : 0 : tmp_p += to_send;
1064 [ # # ]: 0 : } while (len_left > 0);
1065 : :
1066 : : len_left = len;
1067 : :
1068 [ # # ]: 0 : if (len > max_execve_audit_len)
1069 : : too_long = 1;
1070 : :
1071 : : /* rewalk the argument actually logging the message */
1072 [ # # ]: 0 : for (i = 0; len_left > 0; i++) {
1073 : : int room_left;
1074 : :
1075 [ # # ]: 0 : if (len_left > max_execve_audit_len)
1076 : : to_send = max_execve_audit_len;
1077 : : else
1078 : : to_send = len_left;
1079 : :
1080 : : /* do we have space left to send this argument in this ab? */
1081 : 0 : room_left = MAX_EXECVE_AUDIT_LEN - arg_num_len - *len_sent;
1082 [ # # ]: 0 : if (has_cntl)
1083 : 0 : room_left -= (to_send * 2);
1084 : : else
1085 : 0 : room_left -= to_send;
1086 [ # # ]: 0 : if (room_left < 0) {
1087 : 0 : *len_sent = 0;
1088 : 0 : audit_log_end(*ab);
1089 : 0 : *ab = audit_log_start(context, GFP_KERNEL, AUDIT_EXECVE);
1090 [ # # ]: 0 : if (!*ab)
1091 : : return 0;
1092 : : }
1093 : :
1094 : : /*
1095 : : * first record needs to say how long the original string was
1096 : : * so we can be sure nothing was lost.
1097 : : */
1098 [ # # ]: 0 : if ((i == 0) && (too_long))
1099 [ # # ]: 0 : audit_log_format(*ab, " a%d_len=%zu", arg_num,
1100 : : has_cntl ? 2*len : len);
1101 : :
1102 : : /*
1103 : : * normally arguments are small enough to fit and we already
1104 : : * filled buf above when we checked for control characters
1105 : : * so don't bother with another copy_from_user
1106 : : */
1107 [ # # ]: 0 : if (len >= max_execve_audit_len)
1108 : 0 : ret = copy_from_user(buf, p, to_send);
1109 : : else
1110 : : ret = 0;
1111 [ # # ]: 0 : if (ret) {
1112 : 0 : WARN_ON(1);
1113 : 0 : send_sig(SIGKILL, current, 0);
1114 : 0 : return -1;
1115 : : }
1116 : 0 : buf[to_send] = '\0';
1117 : :
1118 : : /* actually log it */
1119 : 0 : audit_log_format(*ab, " a%d", arg_num);
1120 [ # # ]: 0 : if (too_long)
1121 : 0 : audit_log_format(*ab, "[%d]", i);
1122 : 0 : audit_log_format(*ab, "=");
1123 [ # # ]: 0 : if (has_cntl)
1124 : 0 : audit_log_n_hex(*ab, buf, to_send);
1125 : : else
1126 : 0 : audit_log_string(*ab, buf);
1127 : :
1128 : 0 : p += to_send;
1129 : 0 : len_left -= to_send;
1130 : 0 : *len_sent += arg_num_len;
1131 [ # # ]: 0 : if (has_cntl)
1132 : 0 : *len_sent += to_send * 2;
1133 : : else
1134 : 0 : *len_sent += to_send;
1135 : : }
1136 : : /* include the null we didn't log */
1137 : 0 : return len + 1;
1138 : : }
1139 : :
1140 : 0 : static void audit_log_execve_info(struct audit_context *context,
1141 : : struct audit_buffer **ab)
1142 : : {
1143 : : int i, len;
1144 : 0 : size_t len_sent = 0;
1145 : : const char __user *p;
1146 : : char *buf;
1147 : :
1148 : 0 : p = (const char __user *)current->mm->arg_start;
1149 : :
1150 : 0 : audit_log_format(*ab, "argc=%d", context->execve.argc);
1151 : :
1152 : : /*
1153 : : * we need some kernel buffer to hold the userspace args. Just
1154 : : * allocate one big one rather than allocating one of the right size
1155 : : * for every single argument inside audit_log_single_execve_arg()
1156 : : * should be <8k allocation so should be pretty safe.
1157 : : */
1158 : : buf = kmalloc(MAX_EXECVE_AUDIT_LEN + 1, GFP_KERNEL);
1159 [ # # ]: 0 : if (!buf) {
1160 : 0 : audit_panic("out of memory for argv string\n");
1161 : 0 : return;
1162 : : }
1163 : :
1164 [ # # ]: 0 : for (i = 0; i < context->execve.argc; i++) {
1165 : 0 : len = audit_log_single_execve_arg(context, ab, i,
1166 : : &len_sent, p, buf);
1167 [ # # ]: 0 : if (len <= 0)
1168 : : break;
1169 : 0 : p += len;
1170 : : }
1171 : 0 : kfree(buf);
1172 : : }
1173 : :
1174 : 0 : static void show_special(struct audit_context *context, int *call_panic)
1175 : : {
1176 : : struct audit_buffer *ab;
1177 : : int i;
1178 : :
1179 : 0 : ab = audit_log_start(context, GFP_KERNEL, context->type);
1180 [ # # ]: 0 : if (!ab)
1181 : 0 : return;
1182 : :
1183 [ # # # # : 0 : switch (context->type) {
# # # # #
# ]
1184 : : case AUDIT_SOCKETCALL: {
1185 : 0 : int nargs = context->socketcall.nargs;
1186 : 0 : audit_log_format(ab, "nargs=%d", nargs);
1187 [ # # ]: 0 : for (i = 0; i < nargs; i++)
1188 : 0 : audit_log_format(ab, " a%d=%lx", i,
1189 : : context->socketcall.args[i]);
1190 : : break; }
1191 : : case AUDIT_IPC: {
1192 : 0 : u32 osid = context->ipc.osid;
1193 : :
1194 : 0 : audit_log_format(ab, "ouid=%u ogid=%u mode=%#ho",
1195 : : from_kuid(&init_user_ns, context->ipc.uid),
1196 : : from_kgid(&init_user_ns, context->ipc.gid),
1197 : 0 : context->ipc.mode);
1198 [ # # ]: 0 : if (osid) {
1199 : 0 : char *ctx = NULL;
1200 : : u32 len;
1201 [ # # ]: 0 : if (security_secid_to_secctx(osid, &ctx, &len)) {
1202 : 0 : audit_log_format(ab, " osid=%u", osid);
1203 : 0 : *call_panic = 1;
1204 : : } else {
1205 : 0 : audit_log_format(ab, " obj=%s", ctx);
1206 : 0 : security_release_secctx(ctx, len);
1207 : : }
1208 : : }
1209 [ # # ]: 0 : if (context->ipc.has_perm) {
1210 : 0 : audit_log_end(ab);
1211 : 0 : ab = audit_log_start(context, GFP_KERNEL,
1212 : : AUDIT_IPC_SET_PERM);
1213 [ # # ]: 0 : if (unlikely(!ab))
1214 : : return;
1215 : 0 : audit_log_format(ab,
1216 : : "qbytes=%lx ouid=%u ogid=%u mode=%#ho",
1217 : : context->ipc.qbytes,
1218 : : context->ipc.perm_uid,
1219 : : context->ipc.perm_gid,
1220 : 0 : context->ipc.perm_mode);
1221 : : }
1222 : : break; }
1223 : : case AUDIT_MQ_OPEN: {
1224 : 0 : audit_log_format(ab,
1225 : : "oflag=0x%x mode=%#ho mq_flags=0x%lx mq_maxmsg=%ld "
1226 : : "mq_msgsize=%ld mq_curmsgs=%ld",
1227 : 0 : context->mq_open.oflag, context->mq_open.mode,
1228 : : context->mq_open.attr.mq_flags,
1229 : : context->mq_open.attr.mq_maxmsg,
1230 : : context->mq_open.attr.mq_msgsize,
1231 : : context->mq_open.attr.mq_curmsgs);
1232 : 0 : break; }
1233 : : case AUDIT_MQ_SENDRECV: {
1234 : 0 : audit_log_format(ab,
1235 : : "mqdes=%d msg_len=%zd msg_prio=%u "
1236 : : "abs_timeout_sec=%ld abs_timeout_nsec=%ld",
1237 : : context->mq_sendrecv.mqdes,
1238 : : context->mq_sendrecv.msg_len,
1239 : : context->mq_sendrecv.msg_prio,
1240 : : context->mq_sendrecv.abs_timeout.tv_sec,
1241 : : context->mq_sendrecv.abs_timeout.tv_nsec);
1242 : 0 : break; }
1243 : : case AUDIT_MQ_NOTIFY: {
1244 : 0 : audit_log_format(ab, "mqdes=%d sigev_signo=%d",
1245 : : context->mq_notify.mqdes,
1246 : : context->mq_notify.sigev_signo);
1247 : 0 : break; }
1248 : : case AUDIT_MQ_GETSETATTR: {
1249 : : struct mq_attr *attr = &context->mq_getsetattr.mqstat;
1250 : 0 : audit_log_format(ab,
1251 : : "mqdes=%d mq_flags=0x%lx mq_maxmsg=%ld mq_msgsize=%ld "
1252 : : "mq_curmsgs=%ld ",
1253 : : context->mq_getsetattr.mqdes,
1254 : : attr->mq_flags, attr->mq_maxmsg,
1255 : : attr->mq_msgsize, attr->mq_curmsgs);
1256 : 0 : break; }
1257 : : case AUDIT_CAPSET: {
1258 : 0 : audit_log_format(ab, "pid=%d", context->capset.pid);
1259 : 0 : audit_log_cap(ab, "cap_pi", &context->capset.cap.inheritable);
1260 : 0 : audit_log_cap(ab, "cap_pp", &context->capset.cap.permitted);
1261 : 0 : audit_log_cap(ab, "cap_pe", &context->capset.cap.effective);
1262 : 0 : break; }
1263 : : case AUDIT_MMAP: {
1264 : 0 : audit_log_format(ab, "fd=%d flags=0x%x", context->mmap.fd,
1265 : : context->mmap.flags);
1266 : 0 : break; }
1267 : : case AUDIT_EXECVE: {
1268 : 0 : audit_log_execve_info(context, &ab);
1269 : 0 : break; }
1270 : : }
1271 : 0 : audit_log_end(ab);
1272 : : }
1273 : :
1274 : 0 : static void audit_log_exit(struct audit_context *context, struct task_struct *tsk)
1275 : : {
1276 : 0 : int i, call_panic = 0;
1277 : : struct audit_buffer *ab;
1278 : : struct audit_aux_data *aux;
1279 : : struct audit_names *n;
1280 : :
1281 : : /* tsk == current */
1282 : 0 : context->personality = tsk->personality;
1283 : :
1284 : 0 : ab = audit_log_start(context, GFP_KERNEL, AUDIT_SYSCALL);
1285 [ # # ]: 0 : if (!ab)
1286 : 0 : return; /* audit_panic has been called */
1287 : 0 : audit_log_format(ab, "arch=%x syscall=%d",
1288 : : context->arch, context->major);
1289 [ # # ]: 0 : if (context->personality != PER_LINUX)
1290 : 0 : audit_log_format(ab, " per=%lx", context->personality);
1291 [ # # ]: 0 : if (context->return_valid)
1292 [ # # ]: 0 : audit_log_format(ab, " success=%s exit=%ld",
1293 : : (context->return_valid==AUDITSC_SUCCESS)?"yes":"no",
1294 : : context->return_code);
1295 : :
1296 : 0 : audit_log_format(ab,
1297 : : " a0=%lx a1=%lx a2=%lx a3=%lx items=%d",
1298 : : context->argv[0],
1299 : : context->argv[1],
1300 : : context->argv[2],
1301 : : context->argv[3],
1302 : : context->name_count);
1303 : :
1304 : 0 : audit_log_task_info(ab, tsk);
1305 : 0 : audit_log_key(ab, context->filterkey);
1306 : 0 : audit_log_end(ab);
1307 : :
1308 [ # # ]: 0 : for (aux = context->aux; aux; aux = aux->next) {
1309 : :
1310 : 0 : ab = audit_log_start(context, GFP_KERNEL, aux->type);
1311 [ # # ]: 0 : if (!ab)
1312 : 0 : continue; /* audit_panic has been called */
1313 : :
1314 [ # # ]: 0 : switch (aux->type) {
1315 : :
1316 : : case AUDIT_BPRM_FCAPS: {
1317 : : struct audit_aux_data_bprm_fcaps *axs = (void *)aux;
1318 : 0 : audit_log_format(ab, "fver=%x", axs->fcap_ver);
1319 : 0 : audit_log_cap(ab, "fp", &axs->fcap.permitted);
1320 : 0 : audit_log_cap(ab, "fi", &axs->fcap.inheritable);
1321 : 0 : audit_log_format(ab, " fe=%d", axs->fcap.fE);
1322 : 0 : audit_log_cap(ab, "old_pp", &axs->old_pcap.permitted);
1323 : 0 : audit_log_cap(ab, "old_pi", &axs->old_pcap.inheritable);
1324 : 0 : audit_log_cap(ab, "old_pe", &axs->old_pcap.effective);
1325 : 0 : audit_log_cap(ab, "new_pp", &axs->new_pcap.permitted);
1326 : 0 : audit_log_cap(ab, "new_pi", &axs->new_pcap.inheritable);
1327 : 0 : audit_log_cap(ab, "new_pe", &axs->new_pcap.effective);
1328 : 0 : break; }
1329 : :
1330 : : }
1331 : 0 : audit_log_end(ab);
1332 : : }
1333 : :
1334 [ # # ]: 0 : if (context->type)
1335 : 0 : show_special(context, &call_panic);
1336 : :
1337 [ # # ]: 0 : if (context->fds[0] >= 0) {
1338 : 0 : ab = audit_log_start(context, GFP_KERNEL, AUDIT_FD_PAIR);
1339 [ # # ]: 0 : if (ab) {
1340 : 0 : audit_log_format(ab, "fd0=%d fd1=%d",
1341 : : context->fds[0], context->fds[1]);
1342 : 0 : audit_log_end(ab);
1343 : : }
1344 : : }
1345 : :
1346 [ # # ]: 0 : if (context->sockaddr_len) {
1347 : 0 : ab = audit_log_start(context, GFP_KERNEL, AUDIT_SOCKADDR);
1348 [ # # ]: 0 : if (ab) {
1349 : 0 : audit_log_format(ab, "saddr=");
1350 : 0 : audit_log_n_hex(ab, (void *)context->sockaddr,
1351 : : context->sockaddr_len);
1352 : 0 : audit_log_end(ab);
1353 : : }
1354 : : }
1355 : :
1356 [ # # ]: 0 : for (aux = context->aux_pids; aux; aux = aux->next) {
1357 : : struct audit_aux_data_pids *axs = (void *)aux;
1358 : :
1359 [ # # ]: 0 : for (i = 0; i < axs->pid_count; i++)
1360 [ # # ]: 0 : if (audit_log_pid_context(context, axs->target_pid[i],
1361 : : axs->target_auid[i],
1362 : : axs->target_uid[i],
1363 : : axs->target_sessionid[i],
1364 : : axs->target_sid[i],
1365 : 0 : axs->target_comm[i]))
1366 : 0 : call_panic = 1;
1367 : : }
1368 : :
1369 [ # # # # ]: 0 : if (context->target_pid &&
1370 : 0 : audit_log_pid_context(context, context->target_pid,
1371 : : context->target_auid, context->target_uid,
1372 : : context->target_sessionid,
1373 : 0 : context->target_sid, context->target_comm))
1374 : 0 : call_panic = 1;
1375 : :
1376 [ # # ][ # # ]: 0 : if (context->pwd.dentry && context->pwd.mnt) {
1377 : 0 : ab = audit_log_start(context, GFP_KERNEL, AUDIT_CWD);
1378 [ # # ]: 0 : if (ab) {
1379 : 0 : audit_log_d_path(ab, " cwd=", &context->pwd);
1380 : 0 : audit_log_end(ab);
1381 : : }
1382 : : }
1383 : :
1384 : : i = 0;
1385 [ # # ]: 0 : list_for_each_entry(n, &context->names_list, list) {
1386 [ # # ]: 0 : if (n->hidden)
1387 : 0 : continue;
1388 : 0 : audit_log_name(context, n, NULL, i++, &call_panic);
1389 : : }
1390 : :
1391 : : /* Send end of event record to help user space know we are finished */
1392 : 0 : ab = audit_log_start(context, GFP_KERNEL, AUDIT_EOE);
1393 [ # # ]: 0 : if (ab)
1394 : 0 : audit_log_end(ab);
1395 [ # # ]: 0 : if (call_panic)
1396 : 0 : audit_panic("error converting sid to string");
1397 : : }
1398 : :
1399 : : /**
1400 : : * audit_free - free a per-task audit context
1401 : : * @tsk: task whose audit context block to free
1402 : : *
1403 : : * Called from copy_process and do_exit
1404 : : */
1405 : 0 : void __audit_free(struct task_struct *tsk)
1406 : : {
1407 : : struct audit_context *context;
1408 : :
1409 : : context = audit_get_context(tsk, 0, 0);
1410 [ # # ]: 0 : if (!context)
1411 : 0 : return;
1412 : :
1413 : : /* Check for system calls that do not go through the exit
1414 : : * function (e.g., exit_group), then free context block.
1415 : : * We use GFP_ATOMIC here because we might be doing this
1416 : : * in the context of the idle thread */
1417 : : /* that can happen only if we are called from do_exit() */
1418 [ # # ][ # # ]: 0 : if (context->in_syscall && context->current_state == AUDIT_RECORD_CONTEXT)
1419 : 0 : audit_log_exit(context, tsk);
1420 [ # # ]: 0 : if (!list_empty(&context->killed_trees))
1421 : 0 : audit_kill_trees(&context->killed_trees);
1422 : :
1423 : : audit_free_context(context);
1424 : : }
1425 : :
1426 : : /**
1427 : : * audit_syscall_entry - fill in an audit record at syscall entry
1428 : : * @arch: architecture type
1429 : : * @major: major syscall type (function)
1430 : : * @a1: additional syscall register 1
1431 : : * @a2: additional syscall register 2
1432 : : * @a3: additional syscall register 3
1433 : : * @a4: additional syscall register 4
1434 : : *
1435 : : * Fill in audit context at syscall entry. This only happens if the
1436 : : * audit context was created when the task was created and the state or
1437 : : * filters demand the audit context be built. If the state from the
1438 : : * per-task filter or from the per-syscall filter is AUDIT_RECORD_CONTEXT,
1439 : : * then the record will be written at syscall exit time (otherwise, it
1440 : : * will only be written if another part of the kernel requests that it
1441 : : * be written).
1442 : : */
1443 : 0 : void __audit_syscall_entry(int arch, int major,
1444 : : unsigned long a1, unsigned long a2,
1445 : : unsigned long a3, unsigned long a4)
1446 : : {
1447 : 0 : struct task_struct *tsk = current;
1448 : 0 : struct audit_context *context = tsk->audit_context;
1449 : : enum audit_state state;
1450 : :
1451 [ # # ]: 0 : if (!context)
1452 : : return;
1453 : :
1454 [ # # ][ # # ]: 0 : BUG_ON(context->in_syscall || context->name_count);
1455 : :
1456 [ # # ]: 0 : if (!audit_enabled)
1457 : : return;
1458 : :
1459 : 0 : context->arch = arch;
1460 : 0 : context->major = major;
1461 : 0 : context->argv[0] = a1;
1462 : 0 : context->argv[1] = a2;
1463 : 0 : context->argv[2] = a3;
1464 : 0 : context->argv[3] = a4;
1465 : :
1466 : 0 : state = context->state;
1467 : 0 : context->dummy = !audit_n_rules;
1468 [ # # ][ # # ]: 0 : if (!context->dummy && state == AUDIT_BUILD_CONTEXT) {
1469 : 0 : context->prio = 0;
1470 : 0 : state = audit_filter_syscall(tsk, context, &audit_filter_list[AUDIT_FILTER_ENTRY]);
1471 : : }
1472 [ # # ]: 0 : if (state == AUDIT_DISABLED)
1473 : : return;
1474 : :
1475 : 0 : context->serial = 0;
1476 : 0 : context->ctime = CURRENT_TIME;
1477 : 0 : context->in_syscall = 1;
1478 : 0 : context->current_state = state;
1479 : 0 : context->ppid = 0;
1480 : : }
1481 : :
1482 : : /**
1483 : : * audit_syscall_exit - deallocate audit context after a system call
1484 : : * @success: success value of the syscall
1485 : : * @return_code: return value of the syscall
1486 : : *
1487 : : * Tear down after system call. If the audit context has been marked as
1488 : : * auditable (either because of the AUDIT_RECORD_CONTEXT state from
1489 : : * filtering, or because some other part of the kernel wrote an audit
1490 : : * message), then write out the syscall information. In call cases,
1491 : : * free the names stored from getname().
1492 : : */
1493 : 0 : void __audit_syscall_exit(int success, long return_code)
1494 : : {
1495 : 0 : struct task_struct *tsk = current;
1496 : : struct audit_context *context;
1497 : :
1498 [ # # ]: 0 : if (success)
1499 : : success = AUDITSC_SUCCESS;
1500 : : else
1501 : : success = AUDITSC_FAILURE;
1502 : :
1503 : : context = audit_get_context(tsk, success, return_code);
1504 [ # # ]: 0 : if (!context)
1505 : 0 : return;
1506 : :
1507 [ # # ][ # # ]: 0 : if (context->in_syscall && context->current_state == AUDIT_RECORD_CONTEXT)
1508 : 0 : audit_log_exit(context, tsk);
1509 : :
1510 : 0 : context->in_syscall = 0;
1511 [ # # ]: 0 : context->prio = context->state == AUDIT_RECORD_CONTEXT ? ~0ULL : 0;
1512 : :
1513 [ # # ]: 0 : if (!list_empty(&context->killed_trees))
1514 : 0 : audit_kill_trees(&context->killed_trees);
1515 : :
1516 : : audit_free_names(context);
1517 : 0 : unroll_tree_refs(context, NULL, 0);
1518 : : audit_free_aux(context);
1519 : 0 : context->aux = NULL;
1520 : 0 : context->aux_pids = NULL;
1521 : 0 : context->target_pid = 0;
1522 : 0 : context->target_sid = 0;
1523 : 0 : context->sockaddr_len = 0;
1524 : 0 : context->type = 0;
1525 : 0 : context->fds[0] = -1;
1526 [ # # ]: 0 : if (context->state != AUDIT_RECORD_CONTEXT) {
1527 : 0 : kfree(context->filterkey);
1528 : 0 : context->filterkey = NULL;
1529 : : }
1530 : 0 : tsk->audit_context = context;
1531 : : }
1532 : :
1533 : : static inline void handle_one(const struct inode *inode)
1534 : : {
1535 : : #ifdef CONFIG_AUDIT_TREE
1536 : : struct audit_context *context;
1537 : : struct audit_tree_refs *p;
1538 : : struct audit_chunk *chunk;
1539 : : int count;
1540 [ # # ]: 0 : if (likely(hlist_empty(&inode->i_fsnotify_marks)))
1541 : : return;
1542 : : context = current->audit_context;
1543 : 0 : p = context->trees;
1544 : 0 : count = context->tree_count;
1545 : : rcu_read_lock();
1546 : 0 : chunk = audit_tree_lookup(inode);
1547 : : rcu_read_unlock();
1548 [ # # ]: 0 : if (!chunk)
1549 : : return;
1550 [ # # ]: 0 : if (likely(put_tree_ref(context, chunk)))
1551 : : return;
1552 [ # # ]: 0 : if (unlikely(!grow_tree_refs(context))) {
1553 : 0 : printk(KERN_WARNING "out of memory, audit has lost a tree reference\n");
1554 : 0 : audit_set_auditable(context);
1555 : 0 : audit_put_chunk(chunk);
1556 : 0 : unroll_tree_refs(context, p, count);
1557 : : return;
1558 : : }
1559 : 0 : put_tree_ref(context, chunk);
1560 : : #endif
1561 : : }
1562 : :
1563 : 0 : static void handle_path(const struct dentry *dentry)
1564 : : {
1565 : : #ifdef CONFIG_AUDIT_TREE
1566 : : struct audit_context *context;
1567 : : struct audit_tree_refs *p;
1568 : : const struct dentry *d, *parent;
1569 : : struct audit_chunk *drop;
1570 : : unsigned long seq;
1571 : : int count;
1572 : :
1573 : 0 : context = current->audit_context;
1574 : 0 : p = context->trees;
1575 : 0 : count = context->tree_count;
1576 : : retry:
1577 : : drop = NULL;
1578 : : d = dentry;
1579 : : rcu_read_lock();
1580 : : seq = read_seqbegin(&rename_lock);
1581 : : for(;;) {
1582 : 0 : struct inode *inode = d->d_inode;
1583 [ # # ][ # # ]: 0 : if (inode && unlikely(!hlist_empty(&inode->i_fsnotify_marks))) {
1584 : : struct audit_chunk *chunk;
1585 : 0 : chunk = audit_tree_lookup(inode);
1586 [ # # ]: 0 : if (chunk) {
1587 [ # # ]: 0 : if (unlikely(!put_tree_ref(context, chunk))) {
1588 : : drop = chunk;
1589 : : break;
1590 : : }
1591 : : }
1592 : : }
1593 : 0 : parent = d->d_parent;
1594 [ # # ]: 0 : if (parent == d)
1595 : : break;
1596 : : d = parent;
1597 : : }
1598 [ # # ][ # # ]: 0 : if (unlikely(read_seqretry(&rename_lock, seq) || drop)) { /* in this order */
1599 : : rcu_read_unlock();
1600 [ # # ]: 0 : if (!drop) {
1601 : : /* just a race with rename */
1602 : 0 : unroll_tree_refs(context, p, count);
1603 : 0 : goto retry;
1604 : : }
1605 : 0 : audit_put_chunk(drop);
1606 [ # # ]: 0 : if (grow_tree_refs(context)) {
1607 : : /* OK, got more space */
1608 : 0 : unroll_tree_refs(context, p, count);
1609 : 0 : goto retry;
1610 : : }
1611 : : /* too bad */
1612 : 0 : printk(KERN_WARNING
1613 : : "out of memory, audit has lost a tree reference\n");
1614 : 0 : unroll_tree_refs(context, p, count);
1615 : : audit_set_auditable(context);
1616 : 0 : return;
1617 : : }
1618 : : rcu_read_unlock();
1619 : : #endif
1620 : : }
1621 : :
1622 : 0 : static struct audit_names *audit_alloc_name(struct audit_context *context,
1623 : : unsigned char type)
1624 : : {
1625 : : struct audit_names *aname;
1626 : :
1627 [ # # ]: 0 : if (context->name_count < AUDIT_NAMES) {
1628 : 0 : aname = &context->preallocated_names[context->name_count];
1629 : 0 : memset(aname, 0, sizeof(*aname));
1630 : : } else {
1631 : : aname = kzalloc(sizeof(*aname), GFP_NOFS);
1632 [ # # ]: 0 : if (!aname)
1633 : : return NULL;
1634 : 0 : aname->should_free = true;
1635 : : }
1636 : :
1637 : 0 : aname->ino = (unsigned long)-1;
1638 : 0 : aname->type = type;
1639 : 0 : list_add_tail(&aname->list, &context->names_list);
1640 : :
1641 : 0 : context->name_count++;
1642 : : #if AUDIT_DEBUG
1643 : : context->ino_count++;
1644 : : #endif
1645 : 0 : return aname;
1646 : : }
1647 : :
1648 : : /**
1649 : : * audit_reusename - fill out filename with info from existing entry
1650 : : * @uptr: userland ptr to pathname
1651 : : *
1652 : : * Search the audit_names list for the current audit context. If there is an
1653 : : * existing entry with a matching "uptr" then return the filename
1654 : : * associated with that audit_name. If not, return NULL.
1655 : : */
1656 : : struct filename *
1657 : 0 : __audit_reusename(const __user char *uptr)
1658 : : {
1659 : 0 : struct audit_context *context = current->audit_context;
1660 : : struct audit_names *n;
1661 : :
1662 [ # # ]: 0 : list_for_each_entry(n, &context->names_list, list) {
1663 [ # # ]: 0 : if (!n->name)
1664 : 0 : continue;
1665 [ # # ]: 0 : if (n->name->uptr == uptr)
1666 : : return n->name;
1667 : : }
1668 : : return NULL;
1669 : : }
1670 : :
1671 : : /**
1672 : : * audit_getname - add a name to the list
1673 : : * @name: name to add
1674 : : *
1675 : : * Add a name to the list of audit names for this context.
1676 : : * Called from fs/namei.c:getname().
1677 : : */
1678 : 0 : void __audit_getname(struct filename *name)
1679 : : {
1680 : 0 : struct audit_context *context = current->audit_context;
1681 : : struct audit_names *n;
1682 : :
1683 [ # # ]: 0 : if (!context->in_syscall) {
1684 : : #if AUDIT_DEBUG == 2
1685 : : printk(KERN_ERR "%s:%d(:%d): ignoring getname(%p)\n",
1686 : : __FILE__, __LINE__, context->serial, name);
1687 : : dump_stack();
1688 : : #endif
1689 : : return;
1690 : : }
1691 : :
1692 : : #if AUDIT_DEBUG
1693 : : /* The filename _must_ have a populated ->name */
1694 : : BUG_ON(!name->name);
1695 : : #endif
1696 : :
1697 : 0 : n = audit_alloc_name(context, AUDIT_TYPE_UNKNOWN);
1698 [ # # ]: 0 : if (!n)
1699 : : return;
1700 : :
1701 : 0 : n->name = name;
1702 : 0 : n->name_len = AUDIT_NAME_FULL;
1703 : 0 : n->name_put = true;
1704 : 0 : name->aname = n;
1705 : :
1706 [ # # ]: 0 : if (!context->pwd.dentry)
1707 : 0 : get_fs_pwd(current->fs, &context->pwd);
1708 : : }
1709 : :
1710 : : /* audit_putname - intercept a putname request
1711 : : * @name: name to intercept and delay for putname
1712 : : *
1713 : : * If we have stored the name from getname in the audit context,
1714 : : * then we delay the putname until syscall exit.
1715 : : * Called from include/linux/fs.h:putname().
1716 : : */
1717 : 0 : void audit_putname(struct filename *name)
1718 : : {
1719 : 0 : struct audit_context *context = current->audit_context;
1720 : :
1721 [ # # ]: 0 : BUG_ON(!context);
1722 [ # # ][ # # ]: 0 : if (!name->aname || !context->in_syscall) {
1723 : : #if AUDIT_DEBUG == 2
1724 : : printk(KERN_ERR "%s:%d(:%d): final_putname(%p)\n",
1725 : : __FILE__, __LINE__, context->serial, name);
1726 : : if (context->name_count) {
1727 : : struct audit_names *n;
1728 : : int i = 0;
1729 : :
1730 : : list_for_each_entry(n, &context->names_list, list)
1731 : : printk(KERN_ERR "name[%d] = %p = %s\n", i++,
1732 : : n->name, n->name->name ?: "(null)");
1733 : : }
1734 : : #endif
1735 : 0 : final_putname(name);
1736 : : }
1737 : : #if AUDIT_DEBUG
1738 : : else {
1739 : : ++context->put_count;
1740 : : if (context->put_count > context->name_count) {
1741 : : printk(KERN_ERR "%s:%d(:%d): major=%d"
1742 : : " in_syscall=%d putname(%p) name_count=%d"
1743 : : " put_count=%d\n",
1744 : : __FILE__, __LINE__,
1745 : : context->serial, context->major,
1746 : : context->in_syscall, name->name,
1747 : : context->name_count, context->put_count);
1748 : : dump_stack();
1749 : : }
1750 : : }
1751 : : #endif
1752 : 0 : }
1753 : :
1754 : : /**
1755 : : * __audit_inode - store the inode and device from a lookup
1756 : : * @name: name being audited
1757 : : * @dentry: dentry being audited
1758 : : * @flags: attributes for this particular entry
1759 : : */
1760 : 0 : void __audit_inode(struct filename *name, const struct dentry *dentry,
1761 : : unsigned int flags)
1762 : : {
1763 : 0 : struct audit_context *context = current->audit_context;
1764 : 0 : const struct inode *inode = dentry->d_inode;
1765 : : struct audit_names *n;
1766 : 0 : bool parent = flags & AUDIT_INODE_PARENT;
1767 : :
1768 [ # # ]: 0 : if (!context->in_syscall)
1769 : : return;
1770 : :
1771 [ # # ]: 0 : if (!name)
1772 : : goto out_alloc;
1773 : :
1774 : : #if AUDIT_DEBUG
1775 : : /* The struct filename _must_ have a populated ->name */
1776 : : BUG_ON(!name->name);
1777 : : #endif
1778 : : /*
1779 : : * If we have a pointer to an audit_names entry already, then we can
1780 : : * just use it directly if the type is correct.
1781 : : */
1782 : 0 : n = name->aname;
1783 [ # # ]: 0 : if (n) {
1784 [ # # ]: 0 : if (parent) {
1785 [ # # ]: 0 : if (n->type == AUDIT_TYPE_PARENT ||
1786 : : n->type == AUDIT_TYPE_UNKNOWN)
1787 : : goto out;
1788 : : } else {
1789 [ # # ]: 0 : if (n->type != AUDIT_TYPE_PARENT)
1790 : : goto out;
1791 : : }
1792 : : }
1793 : :
1794 [ # # ]: 0 : list_for_each_entry_reverse(n, &context->names_list, list) {
1795 : : /* does the name pointer match? */
1796 [ # # ][ # # ]: 0 : if (!n->name || n->name->name != name->name)
1797 : 0 : continue;
1798 : :
1799 : : /* match the correct record type */
1800 [ # # ]: 0 : if (parent) {
1801 [ # # ]: 0 : if (n->type == AUDIT_TYPE_PARENT ||
1802 : : n->type == AUDIT_TYPE_UNKNOWN)
1803 : : goto out;
1804 : : } else {
1805 [ # # ]: 0 : if (n->type != AUDIT_TYPE_PARENT)
1806 : : goto out;
1807 : : }
1808 : : }
1809 : :
1810 : : out_alloc:
1811 : : /* unable to find the name from a previous getname(). Allocate a new
1812 : : * anonymous entry.
1813 : : */
1814 : 0 : n = audit_alloc_name(context, AUDIT_TYPE_NORMAL);
1815 [ # # ]: 0 : if (!n)
1816 : : return;
1817 : : out:
1818 [ # # ]: 0 : if (parent) {
1819 [ # # ]: 0 : n->name_len = n->name ? parent_len(n->name->name) : AUDIT_NAME_FULL;
1820 : 0 : n->type = AUDIT_TYPE_PARENT;
1821 [ # # ]: 0 : if (flags & AUDIT_INODE_HIDDEN)
1822 : 0 : n->hidden = true;
1823 : : } else {
1824 : 0 : n->name_len = AUDIT_NAME_FULL;
1825 : 0 : n->type = AUDIT_TYPE_NORMAL;
1826 : : }
1827 : 0 : handle_path(dentry);
1828 : 0 : audit_copy_inode(n, dentry, inode);
1829 : : }
1830 : :
1831 : : /**
1832 : : * __audit_inode_child - collect inode info for created/removed objects
1833 : : * @parent: inode of dentry parent
1834 : : * @dentry: dentry being audited
1835 : : * @type: AUDIT_TYPE_* value that we're looking for
1836 : : *
1837 : : * For syscalls that create or remove filesystem objects, audit_inode
1838 : : * can only collect information for the filesystem object's parent.
1839 : : * This call updates the audit context with the child's information.
1840 : : * Syscalls that create a new filesystem object must be hooked after
1841 : : * the object is created. Syscalls that remove a filesystem object
1842 : : * must be hooked prior, in order to capture the target inode during
1843 : : * unsuccessful attempts.
1844 : : */
1845 : 0 : void __audit_inode_child(const struct inode *parent,
1846 : : const struct dentry *dentry,
1847 : : const unsigned char type)
1848 : : {
1849 : 0 : struct audit_context *context = current->audit_context;
1850 : 0 : const struct inode *inode = dentry->d_inode;
1851 : 0 : const char *dname = dentry->d_name.name;
1852 : : struct audit_names *n, *found_parent = NULL, *found_child = NULL;
1853 : :
1854 [ # # ]: 0 : if (!context->in_syscall)
1855 : : return;
1856 : :
1857 [ # # ]: 0 : if (inode)
1858 : : handle_one(inode);
1859 : :
1860 : : /* look for a parent entry first */
1861 [ # # ]: 0 : list_for_each_entry(n, &context->names_list, list) {
1862 [ # # ][ # # ]: 0 : if (!n->name || n->type != AUDIT_TYPE_PARENT)
1863 : 0 : continue;
1864 : :
1865 [ # # # # ]: 0 : if (n->ino == parent->i_ino &&
1866 : 0 : !audit_compare_dname_path(dname, n->name->name, n->name_len)) {
1867 : : found_parent = n;
1868 : : break;
1869 : : }
1870 : : }
1871 : :
1872 : : /* is there a matching child entry? */
1873 [ # # ]: 0 : list_for_each_entry(n, &context->names_list, list) {
1874 : : /* can only match entries that have a name */
1875 [ # # ][ # # ]: 0 : if (!n->name || n->type != type)
1876 : 0 : continue;
1877 : :
1878 : : /* if we found a parent, make sure this one is a child of it */
1879 [ # # ][ # # ]: 0 : if (found_parent && (n->name != found_parent->name))
1880 : 0 : continue;
1881 : :
1882 [ # # # # ]: 0 : if (!strcmp(dname, n->name->name) ||
1883 [ # # ]: 0 : !audit_compare_dname_path(dname, n->name->name,
1884 : : found_parent ?
1885 : : found_parent->name_len :
1886 : : AUDIT_NAME_FULL)) {
1887 : : found_child = n;
1888 : 0 : break;
1889 : : }
1890 : : }
1891 : :
1892 [ # # ]: 0 : if (!found_parent) {
1893 : : /* create a new, "anonymous" parent record */
1894 : 0 : n = audit_alloc_name(context, AUDIT_TYPE_PARENT);
1895 [ # # ]: 0 : if (!n)
1896 : : return;
1897 : 0 : audit_copy_inode(n, NULL, parent);
1898 : : }
1899 : :
1900 [ # # ]: 0 : if (!found_child) {
1901 : 0 : found_child = audit_alloc_name(context, type);
1902 [ # # ]: 0 : if (!found_child)
1903 : : return;
1904 : :
1905 : : /* Re-use the name belonging to the slot for a matching parent
1906 : : * directory. All names for this context are relinquished in
1907 : : * audit_free_names() */
1908 [ # # ]: 0 : if (found_parent) {
1909 : 0 : found_child->name = found_parent->name;
1910 : 0 : found_child->name_len = AUDIT_NAME_FULL;
1911 : : /* don't call __putname() */
1912 : 0 : found_child->name_put = false;
1913 : : }
1914 : : }
1915 [ # # ]: 0 : if (inode)
1916 : 0 : audit_copy_inode(found_child, dentry, inode);
1917 : : else
1918 : 0 : found_child->ino = (unsigned long)-1;
1919 : : }
1920 : : EXPORT_SYMBOL_GPL(__audit_inode_child);
1921 : :
1922 : : /**
1923 : : * auditsc_get_stamp - get local copies of audit_context values
1924 : : * @ctx: audit_context for the task
1925 : : * @t: timespec to store time recorded in the audit_context
1926 : : * @serial: serial value that is recorded in the audit_context
1927 : : *
1928 : : * Also sets the context as auditable.
1929 : : */
1930 : 0 : int auditsc_get_stamp(struct audit_context *ctx,
1931 : : struct timespec *t, unsigned int *serial)
1932 : : {
1933 [ # # ]: 0 : if (!ctx->in_syscall)
1934 : : return 0;
1935 [ # # ]: 0 : if (!ctx->serial)
1936 : 0 : ctx->serial = audit_serial();
1937 : 0 : t->tv_sec = ctx->ctime.tv_sec;
1938 : 0 : t->tv_nsec = ctx->ctime.tv_nsec;
1939 : 0 : *serial = ctx->serial;
1940 [ # # ]: 0 : if (!ctx->prio) {
1941 : 0 : ctx->prio = 1;
1942 : 0 : ctx->current_state = AUDIT_RECORD_CONTEXT;
1943 : : }
1944 : : return 1;
1945 : : }
1946 : :
1947 : : /* global counter which is incremented every time something logs in */
1948 : : static atomic_t session_id = ATOMIC_INIT(0);
1949 : :
1950 : 0 : static int audit_set_loginuid_perm(kuid_t loginuid)
1951 : : {
1952 : : /* if we are unset, we don't need privs */
1953 [ # # ]: 0 : if (!audit_loginuid_set(current))
1954 : : return 0;
1955 : : /* if AUDIT_FEATURE_LOGINUID_IMMUTABLE means never ever allow a change*/
1956 [ # # ]: 0 : if (is_audit_feature_set(AUDIT_FEATURE_LOGINUID_IMMUTABLE))
1957 : : return -EPERM;
1958 : : /* it is set, you need permission */
1959 [ # # ]: 0 : if (!capable(CAP_AUDIT_CONTROL))
1960 : : return -EPERM;
1961 : : /* reject if this is not an unset and we don't allow that */
1962 [ # # ][ # # ]: 0 : if (is_audit_feature_set(AUDIT_FEATURE_ONLY_UNSET_LOGINUID) && uid_valid(loginuid))
1963 : : return -EPERM;
1964 : : return 0;
1965 : : }
1966 : :
1967 : 0 : static void audit_log_set_loginuid(kuid_t koldloginuid, kuid_t kloginuid,
1968 : : unsigned int oldsessionid, unsigned int sessionid,
1969 : : int rc)
1970 : : {
1971 : : struct audit_buffer *ab;
1972 : : uid_t uid, oldloginuid, loginuid;
1973 : :
1974 [ # # ]: 0 : if (!audit_enabled)
1975 : : return;
1976 : :
1977 : 0 : uid = from_kuid(&init_user_ns, task_uid(current));
1978 : : oldloginuid = from_kuid(&init_user_ns, koldloginuid);
1979 : : loginuid = from_kuid(&init_user_ns, kloginuid),
1980 : :
1981 : 0 : ab = audit_log_start(NULL, GFP_KERNEL, AUDIT_LOGIN);
1982 [ # # ]: 0 : if (!ab)
1983 : : return;
1984 : 0 : audit_log_format(ab, "pid=%d uid=%u"
1985 : : " old-auid=%u new-auid=%u old-ses=%u new-ses=%u"
1986 : : " res=%d",
1987 : 0 : current->pid, uid,
1988 : : oldloginuid, loginuid, oldsessionid, sessionid,
1989 : : !rc);
1990 : 0 : audit_log_end(ab);
1991 : : }
1992 : :
1993 : : /**
1994 : : * audit_set_loginuid - set current task's audit_context loginuid
1995 : : * @loginuid: loginuid value
1996 : : *
1997 : : * Returns 0.
1998 : : *
1999 : : * Called (set) from fs/proc/base.c::proc_loginuid_write().
2000 : : */
2001 : 0 : int audit_set_loginuid(kuid_t loginuid)
2002 : : {
2003 : 0 : struct task_struct *task = current;
2004 : : unsigned int oldsessionid, sessionid = (unsigned int)-1;
2005 : : kuid_t oldloginuid;
2006 : : int rc;
2007 : :
2008 : : oldloginuid = audit_get_loginuid(current);
2009 : : oldsessionid = audit_get_sessionid(current);
2010 : :
2011 : 0 : rc = audit_set_loginuid_perm(loginuid);
2012 [ # # ]: 0 : if (rc)
2013 : : goto out;
2014 : :
2015 : : /* are we setting or clearing? */
2016 [ # # ]: 0 : if (uid_valid(loginuid))
2017 : 0 : sessionid = (unsigned int)atomic_inc_return(&session_id);
2018 : :
2019 : 0 : task->sessionid = sessionid;
2020 : 0 : task->loginuid = loginuid;
2021 : : out:
2022 : 0 : audit_log_set_loginuid(oldloginuid, loginuid, oldsessionid, sessionid, rc);
2023 : 0 : return rc;
2024 : : }
2025 : :
2026 : : /**
2027 : : * __audit_mq_open - record audit data for a POSIX MQ open
2028 : : * @oflag: open flag
2029 : : * @mode: mode bits
2030 : : * @attr: queue attributes
2031 : : *
2032 : : */
2033 : 0 : void __audit_mq_open(int oflag, umode_t mode, struct mq_attr *attr)
2034 : : {
2035 : 0 : struct audit_context *context = current->audit_context;
2036 : :
2037 [ # # ]: 0 : if (attr)
2038 : 0 : memcpy(&context->mq_open.attr, attr, sizeof(struct mq_attr));
2039 : : else
2040 : 0 : memset(&context->mq_open.attr, 0, sizeof(struct mq_attr));
2041 : :
2042 : 0 : context->mq_open.oflag = oflag;
2043 : 0 : context->mq_open.mode = mode;
2044 : :
2045 : 0 : context->type = AUDIT_MQ_OPEN;
2046 : 0 : }
2047 : :
2048 : : /**
2049 : : * __audit_mq_sendrecv - record audit data for a POSIX MQ timed send/receive
2050 : : * @mqdes: MQ descriptor
2051 : : * @msg_len: Message length
2052 : : * @msg_prio: Message priority
2053 : : * @abs_timeout: Message timeout in absolute time
2054 : : *
2055 : : */
2056 : 0 : void __audit_mq_sendrecv(mqd_t mqdes, size_t msg_len, unsigned int msg_prio,
2057 : : const struct timespec *abs_timeout)
2058 : : {
2059 : 0 : struct audit_context *context = current->audit_context;
2060 : 0 : struct timespec *p = &context->mq_sendrecv.abs_timeout;
2061 : :
2062 [ # # ]: 0 : if (abs_timeout)
2063 : 0 : memcpy(p, abs_timeout, sizeof(struct timespec));
2064 : : else
2065 : 0 : memset(p, 0, sizeof(struct timespec));
2066 : :
2067 : 0 : context->mq_sendrecv.mqdes = mqdes;
2068 : 0 : context->mq_sendrecv.msg_len = msg_len;
2069 : 0 : context->mq_sendrecv.msg_prio = msg_prio;
2070 : :
2071 : 0 : context->type = AUDIT_MQ_SENDRECV;
2072 : 0 : }
2073 : :
2074 : : /**
2075 : : * __audit_mq_notify - record audit data for a POSIX MQ notify
2076 : : * @mqdes: MQ descriptor
2077 : : * @notification: Notification event
2078 : : *
2079 : : */
2080 : :
2081 : 0 : void __audit_mq_notify(mqd_t mqdes, const struct sigevent *notification)
2082 : : {
2083 : 0 : struct audit_context *context = current->audit_context;
2084 : :
2085 [ # # ]: 0 : if (notification)
2086 : 0 : context->mq_notify.sigev_signo = notification->sigev_signo;
2087 : : else
2088 : 0 : context->mq_notify.sigev_signo = 0;
2089 : :
2090 : 0 : context->mq_notify.mqdes = mqdes;
2091 : 0 : context->type = AUDIT_MQ_NOTIFY;
2092 : 0 : }
2093 : :
2094 : : /**
2095 : : * __audit_mq_getsetattr - record audit data for a POSIX MQ get/set attribute
2096 : : * @mqdes: MQ descriptor
2097 : : * @mqstat: MQ flags
2098 : : *
2099 : : */
2100 : 0 : void __audit_mq_getsetattr(mqd_t mqdes, struct mq_attr *mqstat)
2101 : : {
2102 : 0 : struct audit_context *context = current->audit_context;
2103 : 0 : context->mq_getsetattr.mqdes = mqdes;
2104 : 0 : context->mq_getsetattr.mqstat = *mqstat;
2105 : 0 : context->type = AUDIT_MQ_GETSETATTR;
2106 : 0 : }
2107 : :
2108 : : /**
2109 : : * audit_ipc_obj - record audit data for ipc object
2110 : : * @ipcp: ipc permissions
2111 : : *
2112 : : */
2113 : 0 : void __audit_ipc_obj(struct kern_ipc_perm *ipcp)
2114 : : {
2115 : 0 : struct audit_context *context = current->audit_context;
2116 : 0 : context->ipc.uid = ipcp->uid;
2117 : 0 : context->ipc.gid = ipcp->gid;
2118 : 0 : context->ipc.mode = ipcp->mode;
2119 : 0 : context->ipc.has_perm = 0;
2120 : 0 : security_ipc_getsecid(ipcp, &context->ipc.osid);
2121 : 0 : context->type = AUDIT_IPC;
2122 : 0 : }
2123 : :
2124 : : /**
2125 : : * audit_ipc_set_perm - record audit data for new ipc permissions
2126 : : * @qbytes: msgq bytes
2127 : : * @uid: msgq user id
2128 : : * @gid: msgq group id
2129 : : * @mode: msgq mode (permissions)
2130 : : *
2131 : : * Called only after audit_ipc_obj().
2132 : : */
2133 : 0 : void __audit_ipc_set_perm(unsigned long qbytes, uid_t uid, gid_t gid, umode_t mode)
2134 : : {
2135 : 0 : struct audit_context *context = current->audit_context;
2136 : :
2137 : 0 : context->ipc.qbytes = qbytes;
2138 : 0 : context->ipc.perm_uid = uid;
2139 : 0 : context->ipc.perm_gid = gid;
2140 : 0 : context->ipc.perm_mode = mode;
2141 : 0 : context->ipc.has_perm = 1;
2142 : 0 : }
2143 : :
2144 : 0 : void __audit_bprm(struct linux_binprm *bprm)
2145 : : {
2146 : 0 : struct audit_context *context = current->audit_context;
2147 : :
2148 : 0 : context->type = AUDIT_EXECVE;
2149 : 0 : context->execve.argc = bprm->argc;
2150 : 0 : }
2151 : :
2152 : :
2153 : : /**
2154 : : * audit_socketcall - record audit data for sys_socketcall
2155 : : * @nargs: number of args, which should not be more than AUDITSC_ARGS.
2156 : : * @args: args array
2157 : : *
2158 : : */
2159 : 0 : int __audit_socketcall(int nargs, unsigned long *args)
2160 : : {
2161 : 0 : struct audit_context *context = current->audit_context;
2162 : :
2163 [ # # ][ # # ]: 0 : if (nargs <= 0 || nargs > AUDITSC_ARGS || !args)
2164 : : return -EINVAL;
2165 : 0 : context->type = AUDIT_SOCKETCALL;
2166 : 0 : context->socketcall.nargs = nargs;
2167 : 0 : memcpy(context->socketcall.args, args, nargs * sizeof(unsigned long));
2168 : 0 : return 0;
2169 : : }
2170 : :
2171 : : /**
2172 : : * __audit_fd_pair - record audit data for pipe and socketpair
2173 : : * @fd1: the first file descriptor
2174 : : * @fd2: the second file descriptor
2175 : : *
2176 : : */
2177 : 0 : void __audit_fd_pair(int fd1, int fd2)
2178 : : {
2179 : 0 : struct audit_context *context = current->audit_context;
2180 : 0 : context->fds[0] = fd1;
2181 : 0 : context->fds[1] = fd2;
2182 : 0 : }
2183 : :
2184 : : /**
2185 : : * audit_sockaddr - record audit data for sys_bind, sys_connect, sys_sendto
2186 : : * @len: data length in user space
2187 : : * @a: data address in kernel space
2188 : : *
2189 : : * Returns 0 for success or NULL context or < 0 on error.
2190 : : */
2191 : 0 : int __audit_sockaddr(int len, void *a)
2192 : : {
2193 : 0 : struct audit_context *context = current->audit_context;
2194 : :
2195 [ # # ]: 0 : if (!context->sockaddr) {
2196 : : void *p = kmalloc(sizeof(struct sockaddr_storage), GFP_KERNEL);
2197 [ # # ]: 0 : if (!p)
2198 : : return -ENOMEM;
2199 : 0 : context->sockaddr = p;
2200 : : }
2201 : :
2202 : 0 : context->sockaddr_len = len;
2203 : 0 : memcpy(context->sockaddr, a, len);
2204 : 0 : return 0;
2205 : : }
2206 : :
2207 : 0 : void __audit_ptrace(struct task_struct *t)
2208 : : {
2209 : 0 : struct audit_context *context = current->audit_context;
2210 : :
2211 : 0 : context->target_pid = t->pid;
2212 : 0 : context->target_auid = audit_get_loginuid(t);
2213 : 0 : context->target_uid = task_uid(t);
2214 : 0 : context->target_sessionid = audit_get_sessionid(t);
2215 : 0 : security_task_getsecid(t, &context->target_sid);
2216 : 0 : memcpy(context->target_comm, t->comm, TASK_COMM_LEN);
2217 : 0 : }
2218 : :
2219 : : /**
2220 : : * audit_signal_info - record signal info for shutting down audit subsystem
2221 : : * @sig: signal value
2222 : : * @t: task being signaled
2223 : : *
2224 : : * If the audit subsystem is being terminated, record the task (pid)
2225 : : * and uid that is doing that.
2226 : : */
2227 : 0 : int __audit_signal_info(int sig, struct task_struct *t)
2228 : : {
2229 : : struct audit_aux_data_pids *axp;
2230 : 0 : struct task_struct *tsk = current;
2231 : 0 : struct audit_context *ctx = tsk->audit_context;
2232 : 0 : kuid_t uid = current_uid(), t_uid = task_uid(t);
2233 : :
2234 [ # # ][ # # ]: 0 : if (audit_pid && t->tgid == audit_pid) {
2235 [ # # ][ # # ]: 0 : if (sig == SIGTERM || sig == SIGHUP || sig == SIGUSR1 || sig == SIGUSR2) {
2236 : 0 : audit_sig_pid = tsk->pid;
2237 [ # # ]: 0 : if (uid_valid(tsk->loginuid))
2238 : 0 : audit_sig_uid = tsk->loginuid;
2239 : : else
2240 : 0 : audit_sig_uid = uid;
2241 : 0 : security_task_getsecid(tsk, &audit_sig_sid);
2242 : : }
2243 [ # # ][ # # ]: 0 : if (!audit_signals || audit_dummy_context())
2244 : : return 0;
2245 : : }
2246 : :
2247 : : /* optimize the common case by putting first signal recipient directly
2248 : : * in audit_context */
2249 [ # # ]: 0 : if (!ctx->target_pid) {
2250 : 0 : ctx->target_pid = t->tgid;
2251 : 0 : ctx->target_auid = audit_get_loginuid(t);
2252 : 0 : ctx->target_uid = t_uid;
2253 : 0 : ctx->target_sessionid = audit_get_sessionid(t);
2254 : 0 : security_task_getsecid(t, &ctx->target_sid);
2255 : 0 : memcpy(ctx->target_comm, t->comm, TASK_COMM_LEN);
2256 : 0 : return 0;
2257 : : }
2258 : :
2259 : 0 : axp = (void *)ctx->aux_pids;
2260 [ # # ][ # # ]: 0 : if (!axp || axp->pid_count == AUDIT_AUX_PIDS) {
2261 : : axp = kzalloc(sizeof(*axp), GFP_ATOMIC);
2262 [ # # ]: 0 : if (!axp)
2263 : : return -ENOMEM;
2264 : :
2265 : 0 : axp->d.type = AUDIT_OBJ_PID;
2266 : 0 : axp->d.next = ctx->aux_pids;
2267 : 0 : ctx->aux_pids = (void *)axp;
2268 : : }
2269 [ # # ]: 0 : BUG_ON(axp->pid_count >= AUDIT_AUX_PIDS);
2270 : :
2271 : 0 : axp->target_pid[axp->pid_count] = t->tgid;
2272 : 0 : axp->target_auid[axp->pid_count] = audit_get_loginuid(t);
2273 : 0 : axp->target_uid[axp->pid_count] = t_uid;
2274 : 0 : axp->target_sessionid[axp->pid_count] = audit_get_sessionid(t);
2275 : 0 : security_task_getsecid(t, &axp->target_sid[axp->pid_count]);
2276 : 0 : memcpy(axp->target_comm[axp->pid_count], t->comm, TASK_COMM_LEN);
2277 : 0 : axp->pid_count++;
2278 : :
2279 : 0 : return 0;
2280 : : }
2281 : :
2282 : : /**
2283 : : * __audit_log_bprm_fcaps - store information about a loading bprm and relevant fcaps
2284 : : * @bprm: pointer to the bprm being processed
2285 : : * @new: the proposed new credentials
2286 : : * @old: the old credentials
2287 : : *
2288 : : * Simply check if the proc already has the caps given by the file and if not
2289 : : * store the priv escalation info for later auditing at the end of the syscall
2290 : : *
2291 : : * -Eric
2292 : : */
2293 : 0 : int __audit_log_bprm_fcaps(struct linux_binprm *bprm,
2294 : : const struct cred *new, const struct cred *old)
2295 : : {
2296 : : struct audit_aux_data_bprm_fcaps *ax;
2297 : 0 : struct audit_context *context = current->audit_context;
2298 : : struct cpu_vfs_cap_data vcaps;
2299 : : struct dentry *dentry;
2300 : :
2301 : : ax = kmalloc(sizeof(*ax), GFP_KERNEL);
2302 [ # # ]: 0 : if (!ax)
2303 : : return -ENOMEM;
2304 : :
2305 : 0 : ax->d.type = AUDIT_BPRM_FCAPS;
2306 : 0 : ax->d.next = context->aux;
2307 : 0 : context->aux = (void *)ax;
2308 : :
2309 : 0 : dentry = dget(bprm->file->f_dentry);
2310 : 0 : get_vfs_caps_from_disk(dentry, &vcaps);
2311 : 0 : dput(dentry);
2312 : :
2313 : 0 : ax->fcap.permitted = vcaps.permitted;
2314 : 0 : ax->fcap.inheritable = vcaps.inheritable;
2315 : 0 : ax->fcap.fE = !!(vcaps.magic_etc & VFS_CAP_FLAGS_EFFECTIVE);
2316 : 0 : ax->fcap_ver = (vcaps.magic_etc & VFS_CAP_REVISION_MASK) >> VFS_CAP_REVISION_SHIFT;
2317 : :
2318 : 0 : ax->old_pcap.permitted = old->cap_permitted;
2319 : 0 : ax->old_pcap.inheritable = old->cap_inheritable;
2320 : 0 : ax->old_pcap.effective = old->cap_effective;
2321 : :
2322 : 0 : ax->new_pcap.permitted = new->cap_permitted;
2323 : 0 : ax->new_pcap.inheritable = new->cap_inheritable;
2324 : 0 : ax->new_pcap.effective = new->cap_effective;
2325 : 0 : return 0;
2326 : : }
2327 : :
2328 : : /**
2329 : : * __audit_log_capset - store information about the arguments to the capset syscall
2330 : : * @new: the new credentials
2331 : : * @old: the old (current) credentials
2332 : : *
2333 : : * Record the aguments userspace sent to sys_capset for later printing by the
2334 : : * audit system if applicable
2335 : : */
2336 : 0 : void __audit_log_capset(const struct cred *new, const struct cred *old)
2337 : : {
2338 : 0 : struct audit_context *context = current->audit_context;
2339 : 0 : context->capset.pid = task_pid_nr(current);
2340 : 0 : context->capset.cap.effective = new->cap_effective;
2341 : 0 : context->capset.cap.inheritable = new->cap_effective;
2342 : 0 : context->capset.cap.permitted = new->cap_permitted;
2343 : 0 : context->type = AUDIT_CAPSET;
2344 : 0 : }
2345 : :
2346 : 0 : void __audit_mmap_fd(int fd, int flags)
2347 : : {
2348 : 0 : struct audit_context *context = current->audit_context;
2349 : 0 : context->mmap.fd = fd;
2350 : 0 : context->mmap.flags = flags;
2351 : 0 : context->type = AUDIT_MMAP;
2352 : 0 : }
2353 : :
2354 : 0 : static void audit_log_task(struct audit_buffer *ab)
2355 : : {
2356 : : kuid_t auid, uid;
2357 : : kgid_t gid;
2358 : : unsigned int sessionid;
2359 : 0 : struct mm_struct *mm = current->mm;
2360 : :
2361 : : auid = audit_get_loginuid(current);
2362 : : sessionid = audit_get_sessionid(current);
2363 : 0 : current_uid_gid(&uid, &gid);
2364 : :
2365 : 0 : audit_log_format(ab, "auid=%u uid=%u gid=%u ses=%u",
2366 : : from_kuid(&init_user_ns, auid),
2367 : : from_kuid(&init_user_ns, uid),
2368 : : from_kgid(&init_user_ns, gid),
2369 : : sessionid);
2370 : 0 : audit_log_task_context(ab);
2371 : 0 : audit_log_format(ab, " pid=%d comm=", current->pid);
2372 : 0 : audit_log_untrustedstring(ab, current->comm);
2373 [ # # ]: 0 : if (mm) {
2374 : 0 : down_read(&mm->mmap_sem);
2375 [ # # ]: 0 : if (mm->exe_file)
2376 : 0 : audit_log_d_path(ab, " exe=", &mm->exe_file->f_path);
2377 : 0 : up_read(&mm->mmap_sem);
2378 : : } else
2379 : 0 : audit_log_format(ab, " exe=(null)");
2380 : 0 : }
2381 : :
2382 : : /**
2383 : : * audit_core_dumps - record information about processes that end abnormally
2384 : : * @signr: signal value
2385 : : *
2386 : : * If a process ends with a core dump, something fishy is going on and we
2387 : : * should record the event for investigation.
2388 : : */
2389 : 0 : void audit_core_dumps(long signr)
2390 : : {
2391 : : struct audit_buffer *ab;
2392 : :
2393 [ - + ]: 19 : if (!audit_enabled)
2394 : : return;
2395 : :
2396 [ # # ]: 0 : if (signr == SIGQUIT) /* don't care for those */
2397 : : return;
2398 : :
2399 : 0 : ab = audit_log_start(NULL, GFP_KERNEL, AUDIT_ANOM_ABEND);
2400 [ # # ]: 0 : if (unlikely(!ab))
2401 : : return;
2402 : 0 : audit_log_task(ab);
2403 : 0 : audit_log_format(ab, " sig=%ld", signr);
2404 : 0 : audit_log_end(ab);
2405 : : }
2406 : :
2407 : 0 : void __audit_seccomp(unsigned long syscall, long signr, int code)
2408 : : {
2409 : : struct audit_buffer *ab;
2410 : :
2411 : 0 : ab = audit_log_start(NULL, GFP_KERNEL, AUDIT_SECCOMP);
2412 [ # # ]: 0 : if (unlikely(!ab))
2413 : 0 : return;
2414 : 0 : audit_log_task(ab);
2415 : 0 : audit_log_format(ab, " sig=%ld", signr);
2416 : 0 : audit_log_format(ab, " syscall=%ld", syscall);
2417 : 0 : audit_log_format(ab, " compat=%d", is_compat_task());
2418 : 0 : audit_log_format(ab, " ip=0x%lx", KSTK_EIP(current));
2419 : 0 : audit_log_format(ab, " code=0x%x", code);
2420 : 0 : audit_log_end(ab);
2421 : : }
2422 : :
2423 : 0 : struct list_head *audit_killed_trees(void)
2424 : : {
2425 : 0 : struct audit_context *ctx = current->audit_context;
2426 [ # # ][ # # ]: 0 : if (likely(!ctx || !ctx->in_syscall))
2427 : : return NULL;
2428 : 0 : return &ctx->killed_trees;
2429 : : }
|
