1 // SPDX-License-Identifier: GPL-2.0-or-later
2 /*
3 * Security plug functions
4 *
5 * Copyright (C) 2001 WireX Communications, Inc <chris@wirex.com>
6 * Copyright (C) 2001-2002 Greg Kroah-Hartman <greg@kroah.com>
7 * Copyright (C) 2001 Networks Associates Technology, Inc <ssmalley@nai.com>
8 * Copyright (C) 2016 Mellanox Technologies
9 */
10
11 #define pr_fmt(fmt) "LSM: " fmt
12
13 #include <linux/bpf.h>
14 #include <linux/capability.h>
15 #include <linux/dcache.h>
16 #include <linux/export.h>
17 #include <linux/init.h>
18 #include <linux/kernel.h>
19 #include <linux/kernel_read_file.h>
20 #include <linux/lsm_hooks.h>
21 #include <linux/integrity.h>
22 #include <linux/ima.h>
23 #include <linux/evm.h>
24 #include <linux/fsnotify.h>
25 #include <linux/mman.h>
26 #include <linux/mount.h>
27 #include <linux/personality.h>
28 #include <linux/backing-dev.h>
29 #include <linux/string.h>
30 #include <linux/msg.h>
31 #include <net/flow.h>
32
33 #define MAX_LSM_EVM_XATTR 2
34
35 /* How many LSMs were built into the kernel? */
36 #define LSM_COUNT (__end_lsm_info - __start_lsm_info)
37
38 /*
39 * These are descriptions of the reasons that can be passed to the
40 * security_locked_down() LSM hook. Placing this array here allows
41 * all security modules to use the same descriptions for auditing
42 * purposes.
43 */
44 const char *const lockdown_reasons[LOCKDOWN_CONFIDENTIALITY_MAX+1] = {
45 [LOCKDOWN_NONE] = "none",
46 [LOCKDOWN_MODULE_SIGNATURE] = "unsigned module loading",
47 [LOCKDOWN_DEV_MEM] = "/dev/mem,kmem,port",
48 [LOCKDOWN_EFI_TEST] = "/dev/efi_test access",
49 [LOCKDOWN_KEXEC] = "kexec of unsigned images",
50 [LOCKDOWN_HIBERNATION] = "hibernation",
51 [LOCKDOWN_PCI_ACCESS] = "direct PCI access",
52 [LOCKDOWN_IOPORT] = "raw io port access",
53 [LOCKDOWN_MSR] = "raw MSR access",
54 [LOCKDOWN_ACPI_TABLES] = "modifying ACPI tables",
55 [LOCKDOWN_PCMCIA_CIS] = "direct PCMCIA CIS storage",
56 [LOCKDOWN_TIOCSSERIAL] = "reconfiguration of serial port IO",
57 [LOCKDOWN_MODULE_PARAMETERS] = "unsafe module parameters",
58 [LOCKDOWN_MMIOTRACE] = "unsafe mmio",
59 [LOCKDOWN_DEBUGFS] = "debugfs access",
60 [LOCKDOWN_XMON_WR] = "xmon write access",
61 [LOCKDOWN_BPF_WRITE_USER] = "use of bpf to write user RAM",
62 [LOCKDOWN_DBG_WRITE_KERNEL] = "use of kgdb/kdb to write kernel RAM",
63 [LOCKDOWN_INTEGRITY_MAX] = "integrity",
64 [LOCKDOWN_KCORE] = "/proc/kcore access",
65 [LOCKDOWN_KPROBES] = "use of kprobes",
66 [LOCKDOWN_BPF_READ_KERNEL] = "use of bpf to read kernel RAM",
67 [LOCKDOWN_DBG_READ_KERNEL] = "use of kgdb/kdb to read kernel RAM",
68 [LOCKDOWN_PERF] = "unsafe use of perf",
69 [LOCKDOWN_TRACEFS] = "use of tracefs",
70 [LOCKDOWN_XMON_RW] = "xmon read and write access",
71 [LOCKDOWN_XFRM_SECRET] = "xfrm SA secret",
72 [LOCKDOWN_CONFIDENTIALITY_MAX] = "confidentiality",
73 };
74
75 struct security_hook_heads security_hook_heads __lsm_ro_after_init;
76 static BLOCKING_NOTIFIER_HEAD(blocking_lsm_notifier_chain);
77
78 static struct kmem_cache *lsm_file_cache;
79 static struct kmem_cache *lsm_inode_cache;
80
81 char *lsm_names;
82 static struct lsm_blob_sizes blob_sizes __lsm_ro_after_init;
83
84 /* Boot-time LSM user choice */
85 static __initdata const char *chosen_lsm_order;
86 static __initdata const char *chosen_major_lsm;
87
88 static __initconst const char * const builtin_lsm_order = CONFIG_LSM;
89
90 /* Ordered list of LSMs to initialize. */
91 static __initdata struct lsm_info **ordered_lsms;
92 static __initdata struct lsm_info *exclusive;
93
94 static __initdata bool debug;
95 #define init_debug(...) \
96 do { \
97 if (debug) \
98 pr_info(__VA_ARGS__); \
99 } while (0)
100
is_enabled(struct lsm_info * lsm)101 static bool __init is_enabled(struct lsm_info *lsm)
102 {
103 if (!lsm->enabled)
104 return false;
105
106 return *lsm->enabled;
107 }
108
109 /* Mark an LSM's enabled flag. */
110 static int lsm_enabled_true __initdata = 1;
111 static int lsm_enabled_false __initdata = 0;
set_enabled(struct lsm_info * lsm,bool enabled)112 static void __init set_enabled(struct lsm_info *lsm, bool enabled)
113 {
114 /*
115 * When an LSM hasn't configured an enable variable, we can use
116 * a hard-coded location for storing the default enabled state.
117 */
118 if (!lsm->enabled) {
119 if (enabled)
120 lsm->enabled = &lsm_enabled_true;
121 else
122 lsm->enabled = &lsm_enabled_false;
123 } else if (lsm->enabled == &lsm_enabled_true) {
124 if (!enabled)
125 lsm->enabled = &lsm_enabled_false;
126 } else if (lsm->enabled == &lsm_enabled_false) {
127 if (enabled)
128 lsm->enabled = &lsm_enabled_true;
129 } else {
130 *lsm->enabled = enabled;
131 }
132 }
133
134 /* Is an LSM already listed in the ordered LSMs list? */
exists_ordered_lsm(struct lsm_info * lsm)135 static bool __init exists_ordered_lsm(struct lsm_info *lsm)
136 {
137 struct lsm_info **check;
138
139 for (check = ordered_lsms; *check; check++)
140 if (*check == lsm)
141 return true;
142
143 return false;
144 }
145
146 /* Append an LSM to the list of ordered LSMs to initialize. */
147 static int last_lsm __initdata;
append_ordered_lsm(struct lsm_info * lsm,const char * from)148 static void __init append_ordered_lsm(struct lsm_info *lsm, const char *from)
149 {
150 /* Ignore duplicate selections. */
151 if (exists_ordered_lsm(lsm))
152 return;
153
154 if (WARN(last_lsm == LSM_COUNT, "%s: out of LSM slots!?\n", from))
155 return;
156
157 /* Enable this LSM, if it is not already set. */
158 if (!lsm->enabled)
159 lsm->enabled = &lsm_enabled_true;
160 ordered_lsms[last_lsm++] = lsm;
161
162 init_debug("%s ordering: %s (%sabled)\n", from, lsm->name,
163 is_enabled(lsm) ? "en" : "dis");
164 }
165
166 /* Is an LSM allowed to be initialized? */
lsm_allowed(struct lsm_info * lsm)167 static bool __init lsm_allowed(struct lsm_info *lsm)
168 {
169 /* Skip if the LSM is disabled. */
170 if (!is_enabled(lsm))
171 return false;
172
173 /* Not allowed if another exclusive LSM already initialized. */
174 if ((lsm->flags & LSM_FLAG_EXCLUSIVE) && exclusive) {
175 init_debug("exclusive disabled: %s\n", lsm->name);
176 return false;
177 }
178
179 return true;
180 }
181
lsm_set_blob_size(int * need,int * lbs)182 static void __init lsm_set_blob_size(int *need, int *lbs)
183 {
184 int offset;
185
186 if (*need > 0) {
187 offset = *lbs;
188 *lbs += *need;
189 *need = offset;
190 }
191 }
192
lsm_set_blob_sizes(struct lsm_blob_sizes * needed)193 static void __init lsm_set_blob_sizes(struct lsm_blob_sizes *needed)
194 {
195 if (!needed)
196 return;
197
198 lsm_set_blob_size(&needed->lbs_cred, &blob_sizes.lbs_cred);
199 lsm_set_blob_size(&needed->lbs_file, &blob_sizes.lbs_file);
200 /*
201 * The inode blob gets an rcu_head in addition to
202 * what the modules might need.
203 */
204 if (needed->lbs_inode && blob_sizes.lbs_inode == 0)
205 blob_sizes.lbs_inode = sizeof(struct rcu_head);
206 lsm_set_blob_size(&needed->lbs_inode, &blob_sizes.lbs_inode);
207 lsm_set_blob_size(&needed->lbs_ipc, &blob_sizes.lbs_ipc);
208 lsm_set_blob_size(&needed->lbs_msg_msg, &blob_sizes.lbs_msg_msg);
209 lsm_set_blob_size(&needed->lbs_superblock, &blob_sizes.lbs_superblock);
210 lsm_set_blob_size(&needed->lbs_task, &blob_sizes.lbs_task);
211 }
212
213 /* Prepare LSM for initialization. */
prepare_lsm(struct lsm_info * lsm)214 static void __init prepare_lsm(struct lsm_info *lsm)
215 {
216 int enabled = lsm_allowed(lsm);
217
218 /* Record enablement (to handle any following exclusive LSMs). */
219 set_enabled(lsm, enabled);
220
221 /* If enabled, do pre-initialization work. */
222 if (enabled) {
223 if ((lsm->flags & LSM_FLAG_EXCLUSIVE) && !exclusive) {
224 exclusive = lsm;
225 init_debug("exclusive chosen: %s\n", lsm->name);
226 }
227
228 lsm_set_blob_sizes(lsm->blobs);
229 }
230 }
231
232 /* Initialize a given LSM, if it is enabled. */
initialize_lsm(struct lsm_info * lsm)233 static void __init initialize_lsm(struct lsm_info *lsm)
234 {
235 if (is_enabled(lsm)) {
236 int ret;
237
238 init_debug("initializing %s\n", lsm->name);
239 ret = lsm->init();
240 WARN(ret, "%s failed to initialize: %d\n", lsm->name, ret);
241 }
242 }
243
244 /* Populate ordered LSMs list from comma-separated LSM name list. */
ordered_lsm_parse(const char * order,const char * origin)245 static void __init ordered_lsm_parse(const char *order, const char *origin)
246 {
247 struct lsm_info *lsm;
248 char *sep, *name, *next;
249
250 /* LSM_ORDER_FIRST is always first. */
251 for (lsm = __start_lsm_info; lsm < __end_lsm_info; lsm++) {
252 if (lsm->order == LSM_ORDER_FIRST)
253 append_ordered_lsm(lsm, "first");
254 }
255
256 /* Process "security=", if given. */
257 if (chosen_major_lsm) {
258 struct lsm_info *major;
259
260 /*
261 * To match the original "security=" behavior, this
262 * explicitly does NOT fallback to another Legacy Major
263 * if the selected one was separately disabled: disable
264 * all non-matching Legacy Major LSMs.
265 */
266 for (major = __start_lsm_info; major < __end_lsm_info;
267 major++) {
268 if ((major->flags & LSM_FLAG_LEGACY_MAJOR) &&
269 strcmp(major->name, chosen_major_lsm) != 0) {
270 set_enabled(major, false);
271 init_debug("security=%s disabled: %s\n",
272 chosen_major_lsm, major->name);
273 }
274 }
275 }
276
277 sep = kstrdup(order, GFP_KERNEL);
278 next = sep;
279 /* Walk the list, looking for matching LSMs. */
280 while ((name = strsep(&next, ",")) != NULL) {
281 bool found = false;
282
283 for (lsm = __start_lsm_info; lsm < __end_lsm_info; lsm++) {
284 if (lsm->order == LSM_ORDER_MUTABLE &&
285 strcmp(lsm->name, name) == 0) {
286 append_ordered_lsm(lsm, origin);
287 found = true;
288 }
289 }
290
291 if (!found)
292 init_debug("%s ignored: %s\n", origin, name);
293 }
294
295 /* Process "security=", if given. */
296 if (chosen_major_lsm) {
297 for (lsm = __start_lsm_info; lsm < __end_lsm_info; lsm++) {
298 if (exists_ordered_lsm(lsm))
299 continue;
300 if (strcmp(lsm->name, chosen_major_lsm) == 0)
301 append_ordered_lsm(lsm, "security=");
302 }
303 }
304
305 /* Disable all LSMs not in the ordered list. */
306 for (lsm = __start_lsm_info; lsm < __end_lsm_info; lsm++) {
307 if (exists_ordered_lsm(lsm))
308 continue;
309 set_enabled(lsm, false);
310 init_debug("%s disabled: %s\n", origin, lsm->name);
311 }
312
313 kfree(sep);
314 }
315
316 static void __init lsm_early_cred(struct cred *cred);
317 static void __init lsm_early_task(struct task_struct *task);
318
319 static int lsm_append(const char *new, char **result);
320
ordered_lsm_init(void)321 static void __init ordered_lsm_init(void)
322 {
323 struct lsm_info **lsm;
324
325 ordered_lsms = kcalloc(LSM_COUNT + 1, sizeof(*ordered_lsms),
326 GFP_KERNEL);
327
328 if (chosen_lsm_order) {
329 if (chosen_major_lsm) {
330 pr_info("security= is ignored because it is superseded by lsm=\n");
331 chosen_major_lsm = NULL;
332 }
333 ordered_lsm_parse(chosen_lsm_order, "cmdline");
334 } else
335 ordered_lsm_parse(builtin_lsm_order, "builtin");
336
337 for (lsm = ordered_lsms; *lsm; lsm++)
338 prepare_lsm(*lsm);
339
340 init_debug("cred blob size = %d\n", blob_sizes.lbs_cred);
341 init_debug("file blob size = %d\n", blob_sizes.lbs_file);
342 init_debug("inode blob size = %d\n", blob_sizes.lbs_inode);
343 init_debug("ipc blob size = %d\n", blob_sizes.lbs_ipc);
344 init_debug("msg_msg blob size = %d\n", blob_sizes.lbs_msg_msg);
345 init_debug("superblock blob size = %d\n", blob_sizes.lbs_superblock);
346 init_debug("task blob size = %d\n", blob_sizes.lbs_task);
347
348 /*
349 * Create any kmem_caches needed for blobs
350 */
351 if (blob_sizes.lbs_file)
352 lsm_file_cache = kmem_cache_create("lsm_file_cache",
353 blob_sizes.lbs_file, 0,
354 SLAB_PANIC, NULL);
355 if (blob_sizes.lbs_inode)
356 lsm_inode_cache = kmem_cache_create("lsm_inode_cache",
357 blob_sizes.lbs_inode, 0,
358 SLAB_PANIC, NULL);
359
360 lsm_early_cred((struct cred *) current->cred);
361 lsm_early_task(current);
362 for (lsm = ordered_lsms; *lsm; lsm++)
363 initialize_lsm(*lsm);
364
365 kfree(ordered_lsms);
366 }
367
early_security_init(void)368 int __init early_security_init(void)
369 {
370 int i;
371 struct hlist_head *list = (struct hlist_head *) &security_hook_heads;
372 struct lsm_info *lsm;
373
374 for (i = 0; i < sizeof(security_hook_heads) / sizeof(struct hlist_head);
375 i++)
376 INIT_HLIST_HEAD(&list[i]);
377
378 for (lsm = __start_early_lsm_info; lsm < __end_early_lsm_info; lsm++) {
379 if (!lsm->enabled)
380 lsm->enabled = &lsm_enabled_true;
381 prepare_lsm(lsm);
382 initialize_lsm(lsm);
383 }
384
385 return 0;
386 }
387
388 /**
389 * security_init - initializes the security framework
390 *
391 * This should be called early in the kernel initialization sequence.
392 */
security_init(void)393 int __init security_init(void)
394 {
395 struct lsm_info *lsm;
396
397 pr_info("Security Framework initializing\n");
398
399 /*
400 * Append the names of the early LSM modules now that kmalloc() is
401 * available
402 */
403 for (lsm = __start_early_lsm_info; lsm < __end_early_lsm_info; lsm++) {
404 if (lsm->enabled)
405 lsm_append(lsm->name, &lsm_names);
406 }
407
408 /* Load LSMs in specified order. */
409 ordered_lsm_init();
410
411 return 0;
412 }
413
414 /* Save user chosen LSM */
choose_major_lsm(char * str)415 static int __init choose_major_lsm(char *str)
416 {
417 chosen_major_lsm = str;
418 return 1;
419 }
420 __setup("security=", choose_major_lsm);
421
422 /* Explicitly choose LSM initialization order. */
choose_lsm_order(char * str)423 static int __init choose_lsm_order(char *str)
424 {
425 chosen_lsm_order = str;
426 return 1;
427 }
428 __setup("lsm=", choose_lsm_order);
429
430 /* Enable LSM order debugging. */
enable_debug(char * str)431 static int __init enable_debug(char *str)
432 {
433 debug = true;
434 return 1;
435 }
436 __setup("lsm.debug", enable_debug);
437
match_last_lsm(const char * list,const char * lsm)438 static bool match_last_lsm(const char *list, const char *lsm)
439 {
440 const char *last;
441
442 if (WARN_ON(!list || !lsm))
443 return false;
444 last = strrchr(list, ',');
445 if (last)
446 /* Pass the comma, strcmp() will check for '\0' */
447 last++;
448 else
449 last = list;
450 return !strcmp(last, lsm);
451 }
452
lsm_append(const char * new,char ** result)453 static int lsm_append(const char *new, char **result)
454 {
455 char *cp;
456
457 if (*result == NULL) {
458 *result = kstrdup(new, GFP_KERNEL);
459 if (*result == NULL)
460 return -ENOMEM;
461 } else {
462 /* Check if it is the last registered name */
463 if (match_last_lsm(*result, new))
464 return 0;
465 cp = kasprintf(GFP_KERNEL, "%s,%s", *result, new);
466 if (cp == NULL)
467 return -ENOMEM;
468 kfree(*result);
469 *result = cp;
470 }
471 return 0;
472 }
473
474 /**
475 * security_add_hooks - Add a modules hooks to the hook lists.
476 * @hooks: the hooks to add
477 * @count: the number of hooks to add
478 * @lsm: the name of the security module
479 *
480 * Each LSM has to register its hooks with the infrastructure.
481 */
security_add_hooks(struct security_hook_list * hooks,int count,char * lsm)482 void __init security_add_hooks(struct security_hook_list *hooks, int count,
483 char *lsm)
484 {
485 int i;
486
487 for (i = 0; i < count; i++) {
488 hooks[i].lsm = lsm;
489 hlist_add_tail_rcu(&hooks[i].list, hooks[i].head);
490 }
491
492 /*
493 * Don't try to append during early_security_init(), we'll come back
494 * and fix this up afterwards.
495 */
496 if (slab_is_available()) {
497 if (lsm_append(lsm, &lsm_names) < 0)
498 panic("%s - Cannot get early memory.\n", __func__);
499 }
500 }
501
call_blocking_lsm_notifier(enum lsm_event event,void * data)502 int call_blocking_lsm_notifier(enum lsm_event event, void *data)
503 {
504 return blocking_notifier_call_chain(&blocking_lsm_notifier_chain,
505 event, data);
506 }
507 EXPORT_SYMBOL(call_blocking_lsm_notifier);
508
register_blocking_lsm_notifier(struct notifier_block * nb)509 int register_blocking_lsm_notifier(struct notifier_block *nb)
510 {
511 return blocking_notifier_chain_register(&blocking_lsm_notifier_chain,
512 nb);
513 }
514 EXPORT_SYMBOL(register_blocking_lsm_notifier);
515
unregister_blocking_lsm_notifier(struct notifier_block * nb)516 int unregister_blocking_lsm_notifier(struct notifier_block *nb)
517 {
518 return blocking_notifier_chain_unregister(&blocking_lsm_notifier_chain,
519 nb);
520 }
521 EXPORT_SYMBOL(unregister_blocking_lsm_notifier);
522
523 /**
524 * lsm_cred_alloc - allocate a composite cred blob
525 * @cred: the cred that needs a blob
526 * @gfp: allocation type
527 *
528 * Allocate the cred blob for all the modules
529 *
530 * Returns 0, or -ENOMEM if memory can't be allocated.
531 */
lsm_cred_alloc(struct cred * cred,gfp_t gfp)532 static int lsm_cred_alloc(struct cred *cred, gfp_t gfp)
533 {
534 if (blob_sizes.lbs_cred == 0) {
535 cred->security = NULL;
536 return 0;
537 }
538
539 cred->security = kzalloc(blob_sizes.lbs_cred, gfp);
540 if (cred->security == NULL)
541 return -ENOMEM;
542 return 0;
543 }
544
545 /**
546 * lsm_early_cred - during initialization allocate a composite cred blob
547 * @cred: the cred that needs a blob
548 *
549 * Allocate the cred blob for all the modules
550 */
lsm_early_cred(struct cred * cred)551 static void __init lsm_early_cred(struct cred *cred)
552 {
553 int rc = lsm_cred_alloc(cred, GFP_KERNEL);
554
555 if (rc)
556 panic("%s: Early cred alloc failed.\n", __func__);
557 }
558
559 /**
560 * lsm_file_alloc - allocate a composite file blob
561 * @file: the file that needs a blob
562 *
563 * Allocate the file blob for all the modules
564 *
565 * Returns 0, or -ENOMEM if memory can't be allocated.
566 */
lsm_file_alloc(struct file * file)567 static int lsm_file_alloc(struct file *file)
568 {
569 if (!lsm_file_cache) {
570 file->f_security = NULL;
571 return 0;
572 }
573
574 file->f_security = kmem_cache_zalloc(lsm_file_cache, GFP_KERNEL);
575 if (file->f_security == NULL)
576 return -ENOMEM;
577 return 0;
578 }
579
580 /**
581 * lsm_inode_alloc - allocate a composite inode blob
582 * @inode: the inode that needs a blob
583 *
584 * Allocate the inode blob for all the modules
585 *
586 * Returns 0, or -ENOMEM if memory can't be allocated.
587 */
lsm_inode_alloc(struct inode * inode)588 int lsm_inode_alloc(struct inode *inode)
589 {
590 if (!lsm_inode_cache) {
591 inode->i_security = NULL;
592 return 0;
593 }
594
595 inode->i_security = kmem_cache_zalloc(lsm_inode_cache, GFP_NOFS);
596 if (inode->i_security == NULL)
597 return -ENOMEM;
598 return 0;
599 }
600
601 /**
602 * lsm_task_alloc - allocate a composite task blob
603 * @task: the task that needs a blob
604 *
605 * Allocate the task blob for all the modules
606 *
607 * Returns 0, or -ENOMEM if memory can't be allocated.
608 */
lsm_task_alloc(struct task_struct * task)609 static int lsm_task_alloc(struct task_struct *task)
610 {
611 if (blob_sizes.lbs_task == 0) {
612 task->security = NULL;
613 return 0;
614 }
615
616 task->security = kzalloc(blob_sizes.lbs_task, GFP_KERNEL);
617 if (task->security == NULL)
618 return -ENOMEM;
619 return 0;
620 }
621
622 /**
623 * lsm_ipc_alloc - allocate a composite ipc blob
624 * @kip: the ipc that needs a blob
625 *
626 * Allocate the ipc blob for all the modules
627 *
628 * Returns 0, or -ENOMEM if memory can't be allocated.
629 */
lsm_ipc_alloc(struct kern_ipc_perm * kip)630 static int lsm_ipc_alloc(struct kern_ipc_perm *kip)
631 {
632 if (blob_sizes.lbs_ipc == 0) {
633 kip->security = NULL;
634 return 0;
635 }
636
637 kip->security = kzalloc(blob_sizes.lbs_ipc, GFP_KERNEL);
638 if (kip->security == NULL)
639 return -ENOMEM;
640 return 0;
641 }
642
643 /**
644 * lsm_msg_msg_alloc - allocate a composite msg_msg blob
645 * @mp: the msg_msg that needs a blob
646 *
647 * Allocate the ipc blob for all the modules
648 *
649 * Returns 0, or -ENOMEM if memory can't be allocated.
650 */
lsm_msg_msg_alloc(struct msg_msg * mp)651 static int lsm_msg_msg_alloc(struct msg_msg *mp)
652 {
653 if (blob_sizes.lbs_msg_msg == 0) {
654 mp->security = NULL;
655 return 0;
656 }
657
658 mp->security = kzalloc(blob_sizes.lbs_msg_msg, GFP_KERNEL);
659 if (mp->security == NULL)
660 return -ENOMEM;
661 return 0;
662 }
663
664 /**
665 * lsm_early_task - during initialization allocate a composite task blob
666 * @task: the task that needs a blob
667 *
668 * Allocate the task blob for all the modules
669 */
lsm_early_task(struct task_struct * task)670 static void __init lsm_early_task(struct task_struct *task)
671 {
672 int rc = lsm_task_alloc(task);
673
674 if (rc)
675 panic("%s: Early task alloc failed.\n", __func__);
676 }
677
678 /**
679 * lsm_superblock_alloc - allocate a composite superblock blob
680 * @sb: the superblock that needs a blob
681 *
682 * Allocate the superblock blob for all the modules
683 *
684 * Returns 0, or -ENOMEM if memory can't be allocated.
685 */
lsm_superblock_alloc(struct super_block * sb)686 static int lsm_superblock_alloc(struct super_block *sb)
687 {
688 if (blob_sizes.lbs_superblock == 0) {
689 sb->s_security = NULL;
690 return 0;
691 }
692
693 sb->s_security = kzalloc(blob_sizes.lbs_superblock, GFP_KERNEL);
694 if (sb->s_security == NULL)
695 return -ENOMEM;
696 return 0;
697 }
698
699 /*
700 * The default value of the LSM hook is defined in linux/lsm_hook_defs.h and
701 * can be accessed with:
702 *
703 * LSM_RET_DEFAULT(<hook_name>)
704 *
705 * The macros below define static constants for the default value of each
706 * LSM hook.
707 */
708 #define LSM_RET_DEFAULT(NAME) (NAME##_default)
709 #define DECLARE_LSM_RET_DEFAULT_void(DEFAULT, NAME)
710 #define DECLARE_LSM_RET_DEFAULT_int(DEFAULT, NAME) \
711 static const int LSM_RET_DEFAULT(NAME) = (DEFAULT);
712 #define LSM_HOOK(RET, DEFAULT, NAME, ...) \
713 DECLARE_LSM_RET_DEFAULT_##RET(DEFAULT, NAME)
714
715 #include <linux/lsm_hook_defs.h>
716 #undef LSM_HOOK
717
718 /*
719 * Hook list operation macros.
720 *
721 * call_void_hook:
722 * This is a hook that does not return a value.
723 *
724 * call_int_hook:
725 * This is a hook that returns a value.
726 */
727
728 #define call_void_hook(FUNC, ...) \
729 do { \
730 struct security_hook_list *P; \
731 \
732 hlist_for_each_entry(P, &security_hook_heads.FUNC, list) \
733 P->hook.FUNC(__VA_ARGS__); \
734 } while (0)
735
736 #define call_int_hook(FUNC, IRC, ...) ({ \
737 int RC = IRC; \
738 do { \
739 struct security_hook_list *P; \
740 \
741 hlist_for_each_entry(P, &security_hook_heads.FUNC, list) { \
742 RC = P->hook.FUNC(__VA_ARGS__); \
743 if (RC != 0) \
744 break; \
745 } \
746 } while (0); \
747 RC; \
748 })
749
750 /* Security operations */
751
security_binder_set_context_mgr(const struct cred * mgr)752 int security_binder_set_context_mgr(const struct cred *mgr)
753 {
754 return call_int_hook(binder_set_context_mgr, 0, mgr);
755 }
756
security_binder_transaction(const struct cred * from,const struct cred * to)757 int security_binder_transaction(const struct cred *from,
758 const struct cred *to)
759 {
760 return call_int_hook(binder_transaction, 0, from, to);
761 }
762
security_binder_transfer_binder(const struct cred * from,const struct cred * to)763 int security_binder_transfer_binder(const struct cred *from,
764 const struct cred *to)
765 {
766 return call_int_hook(binder_transfer_binder, 0, from, to);
767 }
768
security_binder_transfer_file(const struct cred * from,const struct cred * to,struct file * file)769 int security_binder_transfer_file(const struct cred *from,
770 const struct cred *to, struct file *file)
771 {
772 return call_int_hook(binder_transfer_file, 0, from, to, file);
773 }
774
security_ptrace_access_check(struct task_struct * child,unsigned int mode)775 int security_ptrace_access_check(struct task_struct *child, unsigned int mode)
776 {
777 return call_int_hook(ptrace_access_check, 0, child, mode);
778 }
779
security_ptrace_traceme(struct task_struct * parent)780 int security_ptrace_traceme(struct task_struct *parent)
781 {
782 return call_int_hook(ptrace_traceme, 0, parent);
783 }
784
security_capget(struct task_struct * target,kernel_cap_t * effective,kernel_cap_t * inheritable,kernel_cap_t * permitted)785 int security_capget(struct task_struct *target,
786 kernel_cap_t *effective,
787 kernel_cap_t *inheritable,
788 kernel_cap_t *permitted)
789 {
790 return call_int_hook(capget, 0, target,
791 effective, inheritable, permitted);
792 }
793
security_capset(struct cred * new,const struct cred * old,const kernel_cap_t * effective,const kernel_cap_t * inheritable,const kernel_cap_t * permitted)794 int security_capset(struct cred *new, const struct cred *old,
795 const kernel_cap_t *effective,
796 const kernel_cap_t *inheritable,
797 const kernel_cap_t *permitted)
798 {
799 return call_int_hook(capset, 0, new, old,
800 effective, inheritable, permitted);
801 }
802
security_capable(const struct cred * cred,struct user_namespace * ns,int cap,unsigned int opts)803 int security_capable(const struct cred *cred,
804 struct user_namespace *ns,
805 int cap,
806 unsigned int opts)
807 {
808 return call_int_hook(capable, 0, cred, ns, cap, opts);
809 }
810
security_quotactl(int cmds,int type,int id,struct super_block * sb)811 int security_quotactl(int cmds, int type, int id, struct super_block *sb)
812 {
813 return call_int_hook(quotactl, 0, cmds, type, id, sb);
814 }
815
security_quota_on(struct dentry * dentry)816 int security_quota_on(struct dentry *dentry)
817 {
818 return call_int_hook(quota_on, 0, dentry);
819 }
820
security_syslog(int type)821 int security_syslog(int type)
822 {
823 return call_int_hook(syslog, 0, type);
824 }
825
security_settime64(const struct timespec64 * ts,const struct timezone * tz)826 int security_settime64(const struct timespec64 *ts, const struct timezone *tz)
827 {
828 return call_int_hook(settime, 0, ts, tz);
829 }
830
security_vm_enough_memory_mm(struct mm_struct * mm,long pages)831 int security_vm_enough_memory_mm(struct mm_struct *mm, long pages)
832 {
833 struct security_hook_list *hp;
834 int cap_sys_admin = 1;
835 int rc;
836
837 /*
838 * The module will respond with a positive value if
839 * it thinks the __vm_enough_memory() call should be
840 * made with the cap_sys_admin set. If all of the modules
841 * agree that it should be set it will. If any module
842 * thinks it should not be set it won't.
843 */
844 hlist_for_each_entry(hp, &security_hook_heads.vm_enough_memory, list) {
845 rc = hp->hook.vm_enough_memory(mm, pages);
846 if (rc <= 0) {
847 cap_sys_admin = 0;
848 break;
849 }
850 }
851 return __vm_enough_memory(mm, pages, cap_sys_admin);
852 }
853
security_bprm_creds_for_exec(struct linux_binprm * bprm)854 int security_bprm_creds_for_exec(struct linux_binprm *bprm)
855 {
856 return call_int_hook(bprm_creds_for_exec, 0, bprm);
857 }
858
security_bprm_creds_from_file(struct linux_binprm * bprm,struct file * file)859 int security_bprm_creds_from_file(struct linux_binprm *bprm, struct file *file)
860 {
861 return call_int_hook(bprm_creds_from_file, 0, bprm, file);
862 }
863
security_bprm_check(struct linux_binprm * bprm)864 int security_bprm_check(struct linux_binprm *bprm)
865 {
866 int ret;
867
868 ret = call_int_hook(bprm_check_security, 0, bprm);
869 if (ret)
870 return ret;
871 return ima_bprm_check(bprm);
872 }
873
security_bprm_committing_creds(struct linux_binprm * bprm)874 void security_bprm_committing_creds(struct linux_binprm *bprm)
875 {
876 call_void_hook(bprm_committing_creds, bprm);
877 }
878
security_bprm_committed_creds(struct linux_binprm * bprm)879 void security_bprm_committed_creds(struct linux_binprm *bprm)
880 {
881 call_void_hook(bprm_committed_creds, bprm);
882 }
883
security_fs_context_dup(struct fs_context * fc,struct fs_context * src_fc)884 int security_fs_context_dup(struct fs_context *fc, struct fs_context *src_fc)
885 {
886 return call_int_hook(fs_context_dup, 0, fc, src_fc);
887 }
888
security_fs_context_parse_param(struct fs_context * fc,struct fs_parameter * param)889 int security_fs_context_parse_param(struct fs_context *fc,
890 struct fs_parameter *param)
891 {
892 struct security_hook_list *hp;
893 int trc;
894 int rc = -ENOPARAM;
895
896 hlist_for_each_entry(hp, &security_hook_heads.fs_context_parse_param,
897 list) {
898 trc = hp->hook.fs_context_parse_param(fc, param);
899 if (trc == 0)
900 rc = 0;
901 else if (trc != -ENOPARAM)
902 return trc;
903 }
904 return rc;
905 }
906
security_sb_alloc(struct super_block * sb)907 int security_sb_alloc(struct super_block *sb)
908 {
909 int rc = lsm_superblock_alloc(sb);
910
911 if (unlikely(rc))
912 return rc;
913 rc = call_int_hook(sb_alloc_security, 0, sb);
914 if (unlikely(rc))
915 security_sb_free(sb);
916 return rc;
917 }
918
security_sb_delete(struct super_block * sb)919 void security_sb_delete(struct super_block *sb)
920 {
921 call_void_hook(sb_delete, sb);
922 }
923
security_sb_free(struct super_block * sb)924 void security_sb_free(struct super_block *sb)
925 {
926 call_void_hook(sb_free_security, sb);
927 kfree(sb->s_security);
928 sb->s_security = NULL;
929 }
930
security_free_mnt_opts(void ** mnt_opts)931 void security_free_mnt_opts(void **mnt_opts)
932 {
933 if (!*mnt_opts)
934 return;
935 call_void_hook(sb_free_mnt_opts, *mnt_opts);
936 *mnt_opts = NULL;
937 }
938 EXPORT_SYMBOL(security_free_mnt_opts);
939
security_sb_eat_lsm_opts(char * options,void ** mnt_opts)940 int security_sb_eat_lsm_opts(char *options, void **mnt_opts)
941 {
942 return call_int_hook(sb_eat_lsm_opts, 0, options, mnt_opts);
943 }
944 EXPORT_SYMBOL(security_sb_eat_lsm_opts);
945
security_sb_mnt_opts_compat(struct super_block * sb,void * mnt_opts)946 int security_sb_mnt_opts_compat(struct super_block *sb,
947 void *mnt_opts)
948 {
949 return call_int_hook(sb_mnt_opts_compat, 0, sb, mnt_opts);
950 }
951 EXPORT_SYMBOL(security_sb_mnt_opts_compat);
952
security_sb_remount(struct super_block * sb,void * mnt_opts)953 int security_sb_remount(struct super_block *sb,
954 void *mnt_opts)
955 {
956 return call_int_hook(sb_remount, 0, sb, mnt_opts);
957 }
958 EXPORT_SYMBOL(security_sb_remount);
959
security_sb_kern_mount(struct super_block * sb)960 int security_sb_kern_mount(struct super_block *sb)
961 {
962 return call_int_hook(sb_kern_mount, 0, sb);
963 }
964
security_sb_show_options(struct seq_file * m,struct super_block * sb)965 int security_sb_show_options(struct seq_file *m, struct super_block *sb)
966 {
967 return call_int_hook(sb_show_options, 0, m, sb);
968 }
969
security_sb_statfs(struct dentry * dentry)970 int security_sb_statfs(struct dentry *dentry)
971 {
972 return call_int_hook(sb_statfs, 0, dentry);
973 }
974
security_sb_mount(const char * dev_name,const struct path * path,const char * type,unsigned long flags,void * data)975 int security_sb_mount(const char *dev_name, const struct path *path,
976 const char *type, unsigned long flags, void *data)
977 {
978 return call_int_hook(sb_mount, 0, dev_name, path, type, flags, data);
979 }
980
security_sb_umount(struct vfsmount * mnt,int flags)981 int security_sb_umount(struct vfsmount *mnt, int flags)
982 {
983 return call_int_hook(sb_umount, 0, mnt, flags);
984 }
985
security_sb_pivotroot(const struct path * old_path,const struct path * new_path)986 int security_sb_pivotroot(const struct path *old_path, const struct path *new_path)
987 {
988 return call_int_hook(sb_pivotroot, 0, old_path, new_path);
989 }
990
security_sb_set_mnt_opts(struct super_block * sb,void * mnt_opts,unsigned long kern_flags,unsigned long * set_kern_flags)991 int security_sb_set_mnt_opts(struct super_block *sb,
992 void *mnt_opts,
993 unsigned long kern_flags,
994 unsigned long *set_kern_flags)
995 {
996 return call_int_hook(sb_set_mnt_opts,
997 mnt_opts ? -EOPNOTSUPP : 0, sb,
998 mnt_opts, kern_flags, set_kern_flags);
999 }
1000 EXPORT_SYMBOL(security_sb_set_mnt_opts);
1001
security_sb_clone_mnt_opts(const struct super_block * oldsb,struct super_block * newsb,unsigned long kern_flags,unsigned long * set_kern_flags)1002 int security_sb_clone_mnt_opts(const struct super_block *oldsb,
1003 struct super_block *newsb,
1004 unsigned long kern_flags,
1005 unsigned long *set_kern_flags)
1006 {
1007 return call_int_hook(sb_clone_mnt_opts, 0, oldsb, newsb,
1008 kern_flags, set_kern_flags);
1009 }
1010 EXPORT_SYMBOL(security_sb_clone_mnt_opts);
1011
security_add_mnt_opt(const char * option,const char * val,int len,void ** mnt_opts)1012 int security_add_mnt_opt(const char *option, const char *val, int len,
1013 void **mnt_opts)
1014 {
1015 return call_int_hook(sb_add_mnt_opt, -EINVAL,
1016 option, val, len, mnt_opts);
1017 }
1018 EXPORT_SYMBOL(security_add_mnt_opt);
1019
security_move_mount(const struct path * from_path,const struct path * to_path)1020 int security_move_mount(const struct path *from_path, const struct path *to_path)
1021 {
1022 return call_int_hook(move_mount, 0, from_path, to_path);
1023 }
1024
security_path_notify(const struct path * path,u64 mask,unsigned int obj_type)1025 int security_path_notify(const struct path *path, u64 mask,
1026 unsigned int obj_type)
1027 {
1028 return call_int_hook(path_notify, 0, path, mask, obj_type);
1029 }
1030
security_inode_alloc(struct inode * inode)1031 int security_inode_alloc(struct inode *inode)
1032 {
1033 int rc = lsm_inode_alloc(inode);
1034
1035 if (unlikely(rc))
1036 return rc;
1037 rc = call_int_hook(inode_alloc_security, 0, inode);
1038 if (unlikely(rc))
1039 security_inode_free(inode);
1040 return rc;
1041 }
1042
inode_free_by_rcu(struct rcu_head * head)1043 static void inode_free_by_rcu(struct rcu_head *head)
1044 {
1045 /*
1046 * The rcu head is at the start of the inode blob
1047 */
1048 kmem_cache_free(lsm_inode_cache, head);
1049 }
1050
security_inode_free(struct inode * inode)1051 void security_inode_free(struct inode *inode)
1052 {
1053 integrity_inode_free(inode);
1054 call_void_hook(inode_free_security, inode);
1055 /*
1056 * The inode may still be referenced in a path walk and
1057 * a call to security_inode_permission() can be made
1058 * after inode_free_security() is called. Ideally, the VFS
1059 * wouldn't do this, but fixing that is a much harder
1060 * job. For now, simply free the i_security via RCU, and
1061 * leave the current inode->i_security pointer intact.
1062 * The inode will be freed after the RCU grace period too.
1063 */
1064 if (inode->i_security)
1065 call_rcu((struct rcu_head *)inode->i_security,
1066 inode_free_by_rcu);
1067 }
1068
security_dentry_init_security(struct dentry * dentry,int mode,const struct qstr * name,const char ** xattr_name,void ** ctx,u32 * ctxlen)1069 int security_dentry_init_security(struct dentry *dentry, int mode,
1070 const struct qstr *name,
1071 const char **xattr_name, void **ctx,
1072 u32 *ctxlen)
1073 {
1074 return call_int_hook(dentry_init_security, -EOPNOTSUPP, dentry, mode,
1075 name, xattr_name, ctx, ctxlen);
1076 }
1077 EXPORT_SYMBOL(security_dentry_init_security);
1078
security_dentry_create_files_as(struct dentry * dentry,int mode,struct qstr * name,const struct cred * old,struct cred * new)1079 int security_dentry_create_files_as(struct dentry *dentry, int mode,
1080 struct qstr *name,
1081 const struct cred *old, struct cred *new)
1082 {
1083 return call_int_hook(dentry_create_files_as, 0, dentry, mode,
1084 name, old, new);
1085 }
1086 EXPORT_SYMBOL(security_dentry_create_files_as);
1087
security_inode_init_security(struct inode * inode,struct inode * dir,const struct qstr * qstr,const initxattrs initxattrs,void * fs_data)1088 int security_inode_init_security(struct inode *inode, struct inode *dir,
1089 const struct qstr *qstr,
1090 const initxattrs initxattrs, void *fs_data)
1091 {
1092 struct xattr new_xattrs[MAX_LSM_EVM_XATTR + 1];
1093 struct xattr *lsm_xattr, *evm_xattr, *xattr;
1094 int ret;
1095
1096 if (unlikely(IS_PRIVATE(inode)))
1097 return 0;
1098
1099 if (!initxattrs)
1100 return call_int_hook(inode_init_security, -EOPNOTSUPP, inode,
1101 dir, qstr, NULL, NULL, NULL);
1102 memset(new_xattrs, 0, sizeof(new_xattrs));
1103 lsm_xattr = new_xattrs;
1104 ret = call_int_hook(inode_init_security, -EOPNOTSUPP, inode, dir, qstr,
1105 &lsm_xattr->name,
1106 &lsm_xattr->value,
1107 &lsm_xattr->value_len);
1108 if (ret)
1109 goto out;
1110
1111 evm_xattr = lsm_xattr + 1;
1112 ret = evm_inode_init_security(inode, lsm_xattr, evm_xattr);
1113 if (ret)
1114 goto out;
1115 ret = initxattrs(inode, new_xattrs, fs_data);
1116 out:
1117 for (xattr = new_xattrs; xattr->value != NULL; xattr++)
1118 kfree(xattr->value);
1119 return (ret == -EOPNOTSUPP) ? 0 : ret;
1120 }
1121 EXPORT_SYMBOL(security_inode_init_security);
1122
security_inode_init_security_anon(struct inode * inode,const struct qstr * name,const struct inode * context_inode)1123 int security_inode_init_security_anon(struct inode *inode,
1124 const struct qstr *name,
1125 const struct inode *context_inode)
1126 {
1127 return call_int_hook(inode_init_security_anon, 0, inode, name,
1128 context_inode);
1129 }
1130
security_old_inode_init_security(struct inode * inode,struct inode * dir,const struct qstr * qstr,const char ** name,void ** value,size_t * len)1131 int security_old_inode_init_security(struct inode *inode, struct inode *dir,
1132 const struct qstr *qstr, const char **name,
1133 void **value, size_t *len)
1134 {
1135 if (unlikely(IS_PRIVATE(inode)))
1136 return -EOPNOTSUPP;
1137 return call_int_hook(inode_init_security, -EOPNOTSUPP, inode, dir,
1138 qstr, name, value, len);
1139 }
1140 EXPORT_SYMBOL(security_old_inode_init_security);
1141
1142 #ifdef CONFIG_SECURITY_PATH
security_path_mknod(const struct path * dir,struct dentry * dentry,umode_t mode,unsigned int dev)1143 int security_path_mknod(const struct path *dir, struct dentry *dentry, umode_t mode,
1144 unsigned int dev)
1145 {
1146 if (unlikely(IS_PRIVATE(d_backing_inode(dir->dentry))))
1147 return 0;
1148 return call_int_hook(path_mknod, 0, dir, dentry, mode, dev);
1149 }
1150 EXPORT_SYMBOL(security_path_mknod);
1151
security_path_mkdir(const struct path * dir,struct dentry * dentry,umode_t mode)1152 int security_path_mkdir(const struct path *dir, struct dentry *dentry, umode_t mode)
1153 {
1154 if (unlikely(IS_PRIVATE(d_backing_inode(dir->dentry))))
1155 return 0;
1156 return call_int_hook(path_mkdir, 0, dir, dentry, mode);
1157 }
1158 EXPORT_SYMBOL(security_path_mkdir);
1159
security_path_rmdir(const struct path * dir,struct dentry * dentry)1160 int security_path_rmdir(const struct path *dir, struct dentry *dentry)
1161 {
1162 if (unlikely(IS_PRIVATE(d_backing_inode(dir->dentry))))
1163 return 0;
1164 return call_int_hook(path_rmdir, 0, dir, dentry);
1165 }
1166
security_path_unlink(const struct path * dir,struct dentry * dentry)1167 int security_path_unlink(const struct path *dir, struct dentry *dentry)
1168 {
1169 if (unlikely(IS_PRIVATE(d_backing_inode(dir->dentry))))
1170 return 0;
1171 return call_int_hook(path_unlink, 0, dir, dentry);
1172 }
1173 EXPORT_SYMBOL(security_path_unlink);
1174
security_path_symlink(const struct path * dir,struct dentry * dentry,const char * old_name)1175 int security_path_symlink(const struct path *dir, struct dentry *dentry,
1176 const char *old_name)
1177 {
1178 if (unlikely(IS_PRIVATE(d_backing_inode(dir->dentry))))
1179 return 0;
1180 return call_int_hook(path_symlink, 0, dir, dentry, old_name);
1181 }
1182
security_path_link(struct dentry * old_dentry,const struct path * new_dir,struct dentry * new_dentry)1183 int security_path_link(struct dentry *old_dentry, const struct path *new_dir,
1184 struct dentry *new_dentry)
1185 {
1186 if (unlikely(IS_PRIVATE(d_backing_inode(old_dentry))))
1187 return 0;
1188 return call_int_hook(path_link, 0, old_dentry, new_dir, new_dentry);
1189 }
1190
security_path_rename(const struct path * old_dir,struct dentry * old_dentry,const struct path * new_dir,struct dentry * new_dentry,unsigned int flags)1191 int security_path_rename(const struct path *old_dir, struct dentry *old_dentry,
1192 const struct path *new_dir, struct dentry *new_dentry,
1193 unsigned int flags)
1194 {
1195 if (unlikely(IS_PRIVATE(d_backing_inode(old_dentry)) ||
1196 (d_is_positive(new_dentry) && IS_PRIVATE(d_backing_inode(new_dentry)))))
1197 return 0;
1198
1199 if (flags & RENAME_EXCHANGE) {
1200 int err = call_int_hook(path_rename, 0, new_dir, new_dentry,
1201 old_dir, old_dentry);
1202 if (err)
1203 return err;
1204 }
1205
1206 return call_int_hook(path_rename, 0, old_dir, old_dentry, new_dir,
1207 new_dentry);
1208 }
1209 EXPORT_SYMBOL(security_path_rename);
1210
security_path_truncate(const struct path * path)1211 int security_path_truncate(const struct path *path)
1212 {
1213 if (unlikely(IS_PRIVATE(d_backing_inode(path->dentry))))
1214 return 0;
1215 return call_int_hook(path_truncate, 0, path);
1216 }
1217
security_path_chmod(const struct path * path,umode_t mode)1218 int security_path_chmod(const struct path *path, umode_t mode)
1219 {
1220 if (unlikely(IS_PRIVATE(d_backing_inode(path->dentry))))
1221 return 0;
1222 return call_int_hook(path_chmod, 0, path, mode);
1223 }
1224
security_path_chown(const struct path * path,kuid_t uid,kgid_t gid)1225 int security_path_chown(const struct path *path, kuid_t uid, kgid_t gid)
1226 {
1227 if (unlikely(IS_PRIVATE(d_backing_inode(path->dentry))))
1228 return 0;
1229 return call_int_hook(path_chown, 0, path, uid, gid);
1230 }
1231
security_path_chroot(const struct path * path)1232 int security_path_chroot(const struct path *path)
1233 {
1234 return call_int_hook(path_chroot, 0, path);
1235 }
1236 #endif
1237
security_inode_create(struct inode * dir,struct dentry * dentry,umode_t mode)1238 int security_inode_create(struct inode *dir, struct dentry *dentry, umode_t mode)
1239 {
1240 if (unlikely(IS_PRIVATE(dir)))
1241 return 0;
1242 return call_int_hook(inode_create, 0, dir, dentry, mode);
1243 }
1244 EXPORT_SYMBOL_GPL(security_inode_create);
1245
security_inode_link(struct dentry * old_dentry,struct inode * dir,struct dentry * new_dentry)1246 int security_inode_link(struct dentry *old_dentry, struct inode *dir,
1247 struct dentry *new_dentry)
1248 {
1249 if (unlikely(IS_PRIVATE(d_backing_inode(old_dentry))))
1250 return 0;
1251 return call_int_hook(inode_link, 0, old_dentry, dir, new_dentry);
1252 }
1253
security_inode_unlink(struct inode * dir,struct dentry * dentry)1254 int security_inode_unlink(struct inode *dir, struct dentry *dentry)
1255 {
1256 if (unlikely(IS_PRIVATE(d_backing_inode(dentry))))
1257 return 0;
1258 return call_int_hook(inode_unlink, 0, dir, dentry);
1259 }
1260
security_inode_symlink(struct inode * dir,struct dentry * dentry,const char * old_name)1261 int security_inode_symlink(struct inode *dir, struct dentry *dentry,
1262 const char *old_name)
1263 {
1264 if (unlikely(IS_PRIVATE(dir)))
1265 return 0;
1266 return call_int_hook(inode_symlink, 0, dir, dentry, old_name);
1267 }
1268
security_inode_mkdir(struct inode * dir,struct dentry * dentry,umode_t mode)1269 int security_inode_mkdir(struct inode *dir, struct dentry *dentry, umode_t mode)
1270 {
1271 if (unlikely(IS_PRIVATE(dir)))
1272 return 0;
1273 return call_int_hook(inode_mkdir, 0, dir, dentry, mode);
1274 }
1275 EXPORT_SYMBOL_GPL(security_inode_mkdir);
1276
security_inode_rmdir(struct inode * dir,struct dentry * dentry)1277 int security_inode_rmdir(struct inode *dir, struct dentry *dentry)
1278 {
1279 if (unlikely(IS_PRIVATE(d_backing_inode(dentry))))
1280 return 0;
1281 return call_int_hook(inode_rmdir, 0, dir, dentry);
1282 }
1283
security_inode_mknod(struct inode * dir,struct dentry * dentry,umode_t mode,dev_t dev)1284 int security_inode_mknod(struct inode *dir, struct dentry *dentry, umode_t mode, dev_t dev)
1285 {
1286 if (unlikely(IS_PRIVATE(dir)))
1287 return 0;
1288 return call_int_hook(inode_mknod, 0, dir, dentry, mode, dev);
1289 }
1290
security_inode_rename(struct inode * old_dir,struct dentry * old_dentry,struct inode * new_dir,struct dentry * new_dentry,unsigned int flags)1291 int security_inode_rename(struct inode *old_dir, struct dentry *old_dentry,
1292 struct inode *new_dir, struct dentry *new_dentry,
1293 unsigned int flags)
1294 {
1295 if (unlikely(IS_PRIVATE(d_backing_inode(old_dentry)) ||
1296 (d_is_positive(new_dentry) && IS_PRIVATE(d_backing_inode(new_dentry)))))
1297 return 0;
1298
1299 if (flags & RENAME_EXCHANGE) {
1300 int err = call_int_hook(inode_rename, 0, new_dir, new_dentry,
1301 old_dir, old_dentry);
1302 if (err)
1303 return err;
1304 }
1305
1306 return call_int_hook(inode_rename, 0, old_dir, old_dentry,
1307 new_dir, new_dentry);
1308 }
1309
security_inode_readlink(struct dentry * dentry)1310 int security_inode_readlink(struct dentry *dentry)
1311 {
1312 if (unlikely(IS_PRIVATE(d_backing_inode(dentry))))
1313 return 0;
1314 return call_int_hook(inode_readlink, 0, dentry);
1315 }
1316
security_inode_follow_link(struct dentry * dentry,struct inode * inode,bool rcu)1317 int security_inode_follow_link(struct dentry *dentry, struct inode *inode,
1318 bool rcu)
1319 {
1320 if (unlikely(IS_PRIVATE(inode)))
1321 return 0;
1322 return call_int_hook(inode_follow_link, 0, dentry, inode, rcu);
1323 }
1324
security_inode_permission(struct inode * inode,int mask)1325 int security_inode_permission(struct inode *inode, int mask)
1326 {
1327 if (unlikely(IS_PRIVATE(inode)))
1328 return 0;
1329 return call_int_hook(inode_permission, 0, inode, mask);
1330 }
1331
security_inode_setattr(struct dentry * dentry,struct iattr * attr)1332 int security_inode_setattr(struct dentry *dentry, struct iattr *attr)
1333 {
1334 int ret;
1335
1336 if (unlikely(IS_PRIVATE(d_backing_inode(dentry))))
1337 return 0;
1338 ret = call_int_hook(inode_setattr, 0, dentry, attr);
1339 if (ret)
1340 return ret;
1341 return evm_inode_setattr(dentry, attr);
1342 }
1343 EXPORT_SYMBOL_GPL(security_inode_setattr);
1344
security_inode_getattr(const struct path * path)1345 int security_inode_getattr(const struct path *path)
1346 {
1347 if (unlikely(IS_PRIVATE(d_backing_inode(path->dentry))))
1348 return 0;
1349 return call_int_hook(inode_getattr, 0, path);
1350 }
1351
security_inode_setxattr(struct user_namespace * mnt_userns,struct dentry * dentry,const char * name,const void * value,size_t size,int flags)1352 int security_inode_setxattr(struct user_namespace *mnt_userns,
1353 struct dentry *dentry, const char *name,
1354 const void *value, size_t size, int flags)
1355 {
1356 int ret;
1357
1358 if (unlikely(IS_PRIVATE(d_backing_inode(dentry))))
1359 return 0;
1360 /*
1361 * SELinux and Smack integrate the cap call,
1362 * so assume that all LSMs supplying this call do so.
1363 */
1364 ret = call_int_hook(inode_setxattr, 1, mnt_userns, dentry, name, value,
1365 size, flags);
1366
1367 if (ret == 1)
1368 ret = cap_inode_setxattr(dentry, name, value, size, flags);
1369 if (ret)
1370 return ret;
1371 ret = ima_inode_setxattr(dentry, name, value, size);
1372 if (ret)
1373 return ret;
1374 return evm_inode_setxattr(mnt_userns, dentry, name, value, size);
1375 }
1376
security_inode_post_setxattr(struct dentry * dentry,const char * name,const void * value,size_t size,int flags)1377 void security_inode_post_setxattr(struct dentry *dentry, const char *name,
1378 const void *value, size_t size, int flags)
1379 {
1380 if (unlikely(IS_PRIVATE(d_backing_inode(dentry))))
1381 return;
1382 call_void_hook(inode_post_setxattr, dentry, name, value, size, flags);
1383 evm_inode_post_setxattr(dentry, name, value, size);
1384 }
1385
security_inode_getxattr(struct dentry * dentry,const char * name)1386 int security_inode_getxattr(struct dentry *dentry, const char *name)
1387 {
1388 if (unlikely(IS_PRIVATE(d_backing_inode(dentry))))
1389 return 0;
1390 return call_int_hook(inode_getxattr, 0, dentry, name);
1391 }
1392
security_inode_listxattr(struct dentry * dentry)1393 int security_inode_listxattr(struct dentry *dentry)
1394 {
1395 if (unlikely(IS_PRIVATE(d_backing_inode(dentry))))
1396 return 0;
1397 return call_int_hook(inode_listxattr, 0, dentry);
1398 }
1399
security_inode_removexattr(struct user_namespace * mnt_userns,struct dentry * dentry,const char * name)1400 int security_inode_removexattr(struct user_namespace *mnt_userns,
1401 struct dentry *dentry, const char *name)
1402 {
1403 int ret;
1404
1405 if (unlikely(IS_PRIVATE(d_backing_inode(dentry))))
1406 return 0;
1407 /*
1408 * SELinux and Smack integrate the cap call,
1409 * so assume that all LSMs supplying this call do so.
1410 */
1411 ret = call_int_hook(inode_removexattr, 1, mnt_userns, dentry, name);
1412 if (ret == 1)
1413 ret = cap_inode_removexattr(mnt_userns, dentry, name);
1414 if (ret)
1415 return ret;
1416 ret = ima_inode_removexattr(dentry, name);
1417 if (ret)
1418 return ret;
1419 return evm_inode_removexattr(mnt_userns, dentry, name);
1420 }
1421
security_inode_need_killpriv(struct dentry * dentry)1422 int security_inode_need_killpriv(struct dentry *dentry)
1423 {
1424 return call_int_hook(inode_need_killpriv, 0, dentry);
1425 }
1426
security_inode_killpriv(struct user_namespace * mnt_userns,struct dentry * dentry)1427 int security_inode_killpriv(struct user_namespace *mnt_userns,
1428 struct dentry *dentry)
1429 {
1430 return call_int_hook(inode_killpriv, 0, mnt_userns, dentry);
1431 }
1432
security_inode_getsecurity(struct user_namespace * mnt_userns,struct inode * inode,const char * name,void ** buffer,bool alloc)1433 int security_inode_getsecurity(struct user_namespace *mnt_userns,
1434 struct inode *inode, const char *name,
1435 void **buffer, bool alloc)
1436 {
1437 struct security_hook_list *hp;
1438 int rc;
1439
1440 if (unlikely(IS_PRIVATE(inode)))
1441 return LSM_RET_DEFAULT(inode_getsecurity);
1442 /*
1443 * Only one module will provide an attribute with a given name.
1444 */
1445 hlist_for_each_entry(hp, &security_hook_heads.inode_getsecurity, list) {
1446 rc = hp->hook.inode_getsecurity(mnt_userns, inode, name, buffer, alloc);
1447 if (rc != LSM_RET_DEFAULT(inode_getsecurity))
1448 return rc;
1449 }
1450 return LSM_RET_DEFAULT(inode_getsecurity);
1451 }
1452
security_inode_setsecurity(struct inode * inode,const char * name,const void * value,size_t size,int flags)1453 int security_inode_setsecurity(struct inode *inode, const char *name, const void *value, size_t size, int flags)
1454 {
1455 struct security_hook_list *hp;
1456 int rc;
1457
1458 if (unlikely(IS_PRIVATE(inode)))
1459 return LSM_RET_DEFAULT(inode_setsecurity);
1460 /*
1461 * Only one module will provide an attribute with a given name.
1462 */
1463 hlist_for_each_entry(hp, &security_hook_heads.inode_setsecurity, list) {
1464 rc = hp->hook.inode_setsecurity(inode, name, value, size,
1465 flags);
1466 if (rc != LSM_RET_DEFAULT(inode_setsecurity))
1467 return rc;
1468 }
1469 return LSM_RET_DEFAULT(inode_setsecurity);
1470 }
1471
security_inode_listsecurity(struct inode * inode,char * buffer,size_t buffer_size)1472 int security_inode_listsecurity(struct inode *inode, char *buffer, size_t buffer_size)
1473 {
1474 if (unlikely(IS_PRIVATE(inode)))
1475 return 0;
1476 return call_int_hook(inode_listsecurity, 0, inode, buffer, buffer_size);
1477 }
1478 EXPORT_SYMBOL(security_inode_listsecurity);
1479
security_inode_getsecid(struct inode * inode,u32 * secid)1480 void security_inode_getsecid(struct inode *inode, u32 *secid)
1481 {
1482 call_void_hook(inode_getsecid, inode, secid);
1483 }
1484
security_inode_copy_up(struct dentry * src,struct cred ** new)1485 int security_inode_copy_up(struct dentry *src, struct cred **new)
1486 {
1487 return call_int_hook(inode_copy_up, 0, src, new);
1488 }
1489 EXPORT_SYMBOL(security_inode_copy_up);
1490
security_inode_copy_up_xattr(const char * name)1491 int security_inode_copy_up_xattr(const char *name)
1492 {
1493 struct security_hook_list *hp;
1494 int rc;
1495
1496 /*
1497 * The implementation can return 0 (accept the xattr), 1 (discard the
1498 * xattr), -EOPNOTSUPP if it does not know anything about the xattr or
1499 * any other error code incase of an error.
1500 */
1501 hlist_for_each_entry(hp,
1502 &security_hook_heads.inode_copy_up_xattr, list) {
1503 rc = hp->hook.inode_copy_up_xattr(name);
1504 if (rc != LSM_RET_DEFAULT(inode_copy_up_xattr))
1505 return rc;
1506 }
1507
1508 return LSM_RET_DEFAULT(inode_copy_up_xattr);
1509 }
1510 EXPORT_SYMBOL(security_inode_copy_up_xattr);
1511
security_kernfs_init_security(struct kernfs_node * kn_dir,struct kernfs_node * kn)1512 int security_kernfs_init_security(struct kernfs_node *kn_dir,
1513 struct kernfs_node *kn)
1514 {
1515 return call_int_hook(kernfs_init_security, 0, kn_dir, kn);
1516 }
1517
security_file_permission(struct file * file,int mask)1518 int security_file_permission(struct file *file, int mask)
1519 {
1520 int ret;
1521
1522 ret = call_int_hook(file_permission, 0, file, mask);
1523 if (ret)
1524 return ret;
1525
1526 return fsnotify_perm(file, mask);
1527 }
1528
security_file_alloc(struct file * file)1529 int security_file_alloc(struct file *file)
1530 {
1531 int rc = lsm_file_alloc(file);
1532
1533 if (rc)
1534 return rc;
1535 rc = call_int_hook(file_alloc_security, 0, file);
1536 if (unlikely(rc))
1537 security_file_free(file);
1538 return rc;
1539 }
1540
security_file_free(struct file * file)1541 void security_file_free(struct file *file)
1542 {
1543 void *blob;
1544
1545 call_void_hook(file_free_security, file);
1546
1547 blob = file->f_security;
1548 if (blob) {
1549 file->f_security = NULL;
1550 kmem_cache_free(lsm_file_cache, blob);
1551 }
1552 }
1553
security_file_ioctl(struct file * file,unsigned int cmd,unsigned long arg)1554 int security_file_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
1555 {
1556 return call_int_hook(file_ioctl, 0, file, cmd, arg);
1557 }
1558 EXPORT_SYMBOL_GPL(security_file_ioctl);
1559
1560 /**
1561 * security_file_ioctl_compat() - Check if an ioctl is allowed in compat mode
1562 * @file: associated file
1563 * @cmd: ioctl cmd
1564 * @arg: ioctl arguments
1565 *
1566 * Compat version of security_file_ioctl() that correctly handles 32-bit
1567 * processes running on 64-bit kernels.
1568 *
1569 * Return: Returns 0 if permission is granted.
1570 */
security_file_ioctl_compat(struct file * file,unsigned int cmd,unsigned long arg)1571 int security_file_ioctl_compat(struct file *file, unsigned int cmd,
1572 unsigned long arg)
1573 {
1574 return call_int_hook(file_ioctl_compat, 0, file, cmd, arg);
1575 }
1576 EXPORT_SYMBOL_GPL(security_file_ioctl_compat);
1577
mmap_prot(struct file * file,unsigned long prot)1578 static inline unsigned long mmap_prot(struct file *file, unsigned long prot)
1579 {
1580 /*
1581 * Does we have PROT_READ and does the application expect
1582 * it to imply PROT_EXEC? If not, nothing to talk about...
1583 */
1584 if ((prot & (PROT_READ | PROT_EXEC)) != PROT_READ)
1585 return prot;
1586 if (!(current->personality & READ_IMPLIES_EXEC))
1587 return prot;
1588 /*
1589 * if that's an anonymous mapping, let it.
1590 */
1591 if (!file)
1592 return prot | PROT_EXEC;
1593 /*
1594 * ditto if it's not on noexec mount, except that on !MMU we need
1595 * NOMMU_MAP_EXEC (== VM_MAYEXEC) in this case
1596 */
1597 if (!path_noexec(&file->f_path)) {
1598 #ifndef CONFIG_MMU
1599 if (file->f_op->mmap_capabilities) {
1600 unsigned caps = file->f_op->mmap_capabilities(file);
1601 if (!(caps & NOMMU_MAP_EXEC))
1602 return prot;
1603 }
1604 #endif
1605 return prot | PROT_EXEC;
1606 }
1607 /* anything on noexec mount won't get PROT_EXEC */
1608 return prot;
1609 }
1610
security_mmap_file(struct file * file,unsigned long prot,unsigned long flags)1611 int security_mmap_file(struct file *file, unsigned long prot,
1612 unsigned long flags)
1613 {
1614 unsigned long prot_adj = mmap_prot(file, prot);
1615 int ret;
1616
1617 ret = call_int_hook(mmap_file, 0, file, prot, prot_adj, flags);
1618 if (ret)
1619 return ret;
1620 return ima_file_mmap(file, prot, prot_adj, flags);
1621 }
1622
security_mmap_addr(unsigned long addr)1623 int security_mmap_addr(unsigned long addr)
1624 {
1625 return call_int_hook(mmap_addr, 0, addr);
1626 }
1627
security_file_mprotect(struct vm_area_struct * vma,unsigned long reqprot,unsigned long prot)1628 int security_file_mprotect(struct vm_area_struct *vma, unsigned long reqprot,
1629 unsigned long prot)
1630 {
1631 int ret;
1632
1633 ret = call_int_hook(file_mprotect, 0, vma, reqprot, prot);
1634 if (ret)
1635 return ret;
1636 return ima_file_mprotect(vma, prot);
1637 }
1638
security_file_lock(struct file * file,unsigned int cmd)1639 int security_file_lock(struct file *file, unsigned int cmd)
1640 {
1641 return call_int_hook(file_lock, 0, file, cmd);
1642 }
1643
security_file_fcntl(struct file * file,unsigned int cmd,unsigned long arg)1644 int security_file_fcntl(struct file *file, unsigned int cmd, unsigned long arg)
1645 {
1646 return call_int_hook(file_fcntl, 0, file, cmd, arg);
1647 }
1648
security_file_set_fowner(struct file * file)1649 void security_file_set_fowner(struct file *file)
1650 {
1651 call_void_hook(file_set_fowner, file);
1652 }
1653
security_file_send_sigiotask(struct task_struct * tsk,struct fown_struct * fown,int sig)1654 int security_file_send_sigiotask(struct task_struct *tsk,
1655 struct fown_struct *fown, int sig)
1656 {
1657 return call_int_hook(file_send_sigiotask, 0, tsk, fown, sig);
1658 }
1659
security_file_receive(struct file * file)1660 int security_file_receive(struct file *file)
1661 {
1662 return call_int_hook(file_receive, 0, file);
1663 }
1664
security_file_open(struct file * file)1665 int security_file_open(struct file *file)
1666 {
1667 int ret;
1668
1669 ret = call_int_hook(file_open, 0, file);
1670 if (ret)
1671 return ret;
1672
1673 return fsnotify_perm(file, MAY_OPEN);
1674 }
1675
security_task_alloc(struct task_struct * task,unsigned long clone_flags)1676 int security_task_alloc(struct task_struct *task, unsigned long clone_flags)
1677 {
1678 int rc = lsm_task_alloc(task);
1679
1680 if (rc)
1681 return rc;
1682 rc = call_int_hook(task_alloc, 0, task, clone_flags);
1683 if (unlikely(rc))
1684 security_task_free(task);
1685 return rc;
1686 }
1687
security_task_free(struct task_struct * task)1688 void security_task_free(struct task_struct *task)
1689 {
1690 call_void_hook(task_free, task);
1691
1692 kfree(task->security);
1693 task->security = NULL;
1694 }
1695
security_cred_alloc_blank(struct cred * cred,gfp_t gfp)1696 int security_cred_alloc_blank(struct cred *cred, gfp_t gfp)
1697 {
1698 int rc = lsm_cred_alloc(cred, gfp);
1699
1700 if (rc)
1701 return rc;
1702
1703 rc = call_int_hook(cred_alloc_blank, 0, cred, gfp);
1704 if (unlikely(rc))
1705 security_cred_free(cred);
1706 return rc;
1707 }
1708
security_cred_free(struct cred * cred)1709 void security_cred_free(struct cred *cred)
1710 {
1711 /*
1712 * There is a failure case in prepare_creds() that
1713 * may result in a call here with ->security being NULL.
1714 */
1715 if (unlikely(cred->security == NULL))
1716 return;
1717
1718 call_void_hook(cred_free, cred);
1719
1720 kfree(cred->security);
1721 cred->security = NULL;
1722 }
1723
security_prepare_creds(struct cred * new,const struct cred * old,gfp_t gfp)1724 int security_prepare_creds(struct cred *new, const struct cred *old, gfp_t gfp)
1725 {
1726 int rc = lsm_cred_alloc(new, gfp);
1727
1728 if (rc)
1729 return rc;
1730
1731 rc = call_int_hook(cred_prepare, 0, new, old, gfp);
1732 if (unlikely(rc))
1733 security_cred_free(new);
1734 return rc;
1735 }
1736
security_transfer_creds(struct cred * new,const struct cred * old)1737 void security_transfer_creds(struct cred *new, const struct cred *old)
1738 {
1739 call_void_hook(cred_transfer, new, old);
1740 }
1741
security_cred_getsecid(const struct cred * c,u32 * secid)1742 void security_cred_getsecid(const struct cred *c, u32 *secid)
1743 {
1744 *secid = 0;
1745 call_void_hook(cred_getsecid, c, secid);
1746 }
1747 EXPORT_SYMBOL(security_cred_getsecid);
1748
security_kernel_act_as(struct cred * new,u32 secid)1749 int security_kernel_act_as(struct cred *new, u32 secid)
1750 {
1751 return call_int_hook(kernel_act_as, 0, new, secid);
1752 }
1753
security_kernel_create_files_as(struct cred * new,struct inode * inode)1754 int security_kernel_create_files_as(struct cred *new, struct inode *inode)
1755 {
1756 return call_int_hook(kernel_create_files_as, 0, new, inode);
1757 }
1758
security_kernel_module_request(char * kmod_name)1759 int security_kernel_module_request(char *kmod_name)
1760 {
1761 int ret;
1762
1763 ret = call_int_hook(kernel_module_request, 0, kmod_name);
1764 if (ret)
1765 return ret;
1766 return integrity_kernel_module_request(kmod_name);
1767 }
1768
security_kernel_read_file(struct file * file,enum kernel_read_file_id id,bool contents)1769 int security_kernel_read_file(struct file *file, enum kernel_read_file_id id,
1770 bool contents)
1771 {
1772 int ret;
1773
1774 ret = call_int_hook(kernel_read_file, 0, file, id, contents);
1775 if (ret)
1776 return ret;
1777 return ima_read_file(file, id, contents);
1778 }
1779 EXPORT_SYMBOL_GPL(security_kernel_read_file);
1780
security_kernel_post_read_file(struct file * file,char * buf,loff_t size,enum kernel_read_file_id id)1781 int security_kernel_post_read_file(struct file *file, char *buf, loff_t size,
1782 enum kernel_read_file_id id)
1783 {
1784 int ret;
1785
1786 ret = call_int_hook(kernel_post_read_file, 0, file, buf, size, id);
1787 if (ret)
1788 return ret;
1789 return ima_post_read_file(file, buf, size, id);
1790 }
1791 EXPORT_SYMBOL_GPL(security_kernel_post_read_file);
1792
security_kernel_load_data(enum kernel_load_data_id id,bool contents)1793 int security_kernel_load_data(enum kernel_load_data_id id, bool contents)
1794 {
1795 int ret;
1796
1797 ret = call_int_hook(kernel_load_data, 0, id, contents);
1798 if (ret)
1799 return ret;
1800 return ima_load_data(id, contents);
1801 }
1802 EXPORT_SYMBOL_GPL(security_kernel_load_data);
1803
security_kernel_post_load_data(char * buf,loff_t size,enum kernel_load_data_id id,char * description)1804 int security_kernel_post_load_data(char *buf, loff_t size,
1805 enum kernel_load_data_id id,
1806 char *description)
1807 {
1808 int ret;
1809
1810 ret = call_int_hook(kernel_post_load_data, 0, buf, size, id,
1811 description);
1812 if (ret)
1813 return ret;
1814 return ima_post_load_data(buf, size, id, description);
1815 }
1816 EXPORT_SYMBOL_GPL(security_kernel_post_load_data);
1817
security_task_fix_setuid(struct cred * new,const struct cred * old,int flags)1818 int security_task_fix_setuid(struct cred *new, const struct cred *old,
1819 int flags)
1820 {
1821 return call_int_hook(task_fix_setuid, 0, new, old, flags);
1822 }
1823
security_task_fix_setgid(struct cred * new,const struct cred * old,int flags)1824 int security_task_fix_setgid(struct cred *new, const struct cred *old,
1825 int flags)
1826 {
1827 return call_int_hook(task_fix_setgid, 0, new, old, flags);
1828 }
1829
security_task_setpgid(struct task_struct * p,pid_t pgid)1830 int security_task_setpgid(struct task_struct *p, pid_t pgid)
1831 {
1832 return call_int_hook(task_setpgid, 0, p, pgid);
1833 }
1834
security_task_getpgid(struct task_struct * p)1835 int security_task_getpgid(struct task_struct *p)
1836 {
1837 return call_int_hook(task_getpgid, 0, p);
1838 }
1839
security_task_getsid(struct task_struct * p)1840 int security_task_getsid(struct task_struct *p)
1841 {
1842 return call_int_hook(task_getsid, 0, p);
1843 }
1844
security_task_getsecid_subj(struct task_struct * p,u32 * secid)1845 void security_task_getsecid_subj(struct task_struct *p, u32 *secid)
1846 {
1847 *secid = 0;
1848 call_void_hook(task_getsecid_subj, p, secid);
1849 }
1850 EXPORT_SYMBOL(security_task_getsecid_subj);
1851
security_task_getsecid_obj(struct task_struct * p,u32 * secid)1852 void security_task_getsecid_obj(struct task_struct *p, u32 *secid)
1853 {
1854 *secid = 0;
1855 call_void_hook(task_getsecid_obj, p, secid);
1856 }
1857 EXPORT_SYMBOL(security_task_getsecid_obj);
1858
security_task_setnice(struct task_struct * p,int nice)1859 int security_task_setnice(struct task_struct *p, int nice)
1860 {
1861 return call_int_hook(task_setnice, 0, p, nice);
1862 }
1863
security_task_setioprio(struct task_struct * p,int ioprio)1864 int security_task_setioprio(struct task_struct *p, int ioprio)
1865 {
1866 return call_int_hook(task_setioprio, 0, p, ioprio);
1867 }
1868
security_task_getioprio(struct task_struct * p)1869 int security_task_getioprio(struct task_struct *p)
1870 {
1871 return call_int_hook(task_getioprio, 0, p);
1872 }
1873
security_task_prlimit(const struct cred * cred,const struct cred * tcred,unsigned int flags)1874 int security_task_prlimit(const struct cred *cred, const struct cred *tcred,
1875 unsigned int flags)
1876 {
1877 return call_int_hook(task_prlimit, 0, cred, tcred, flags);
1878 }
1879
security_task_setrlimit(struct task_struct * p,unsigned int resource,struct rlimit * new_rlim)1880 int security_task_setrlimit(struct task_struct *p, unsigned int resource,
1881 struct rlimit *new_rlim)
1882 {
1883 return call_int_hook(task_setrlimit, 0, p, resource, new_rlim);
1884 }
1885
security_task_setscheduler(struct task_struct * p)1886 int security_task_setscheduler(struct task_struct *p)
1887 {
1888 return call_int_hook(task_setscheduler, 0, p);
1889 }
1890
security_task_getscheduler(struct task_struct * p)1891 int security_task_getscheduler(struct task_struct *p)
1892 {
1893 return call_int_hook(task_getscheduler, 0, p);
1894 }
1895
security_task_movememory(struct task_struct * p)1896 int security_task_movememory(struct task_struct *p)
1897 {
1898 return call_int_hook(task_movememory, 0, p);
1899 }
1900
security_task_kill(struct task_struct * p,struct kernel_siginfo * info,int sig,const struct cred * cred)1901 int security_task_kill(struct task_struct *p, struct kernel_siginfo *info,
1902 int sig, const struct cred *cred)
1903 {
1904 return call_int_hook(task_kill, 0, p, info, sig, cred);
1905 }
1906
security_task_prctl(int option,unsigned long arg2,unsigned long arg3,unsigned long arg4,unsigned long arg5)1907 int security_task_prctl(int option, unsigned long arg2, unsigned long arg3,
1908 unsigned long arg4, unsigned long arg5)
1909 {
1910 int thisrc;
1911 int rc = LSM_RET_DEFAULT(task_prctl);
1912 struct security_hook_list *hp;
1913
1914 hlist_for_each_entry(hp, &security_hook_heads.task_prctl, list) {
1915 thisrc = hp->hook.task_prctl(option, arg2, arg3, arg4, arg5);
1916 if (thisrc != LSM_RET_DEFAULT(task_prctl)) {
1917 rc = thisrc;
1918 if (thisrc != 0)
1919 break;
1920 }
1921 }
1922 return rc;
1923 }
1924
security_task_to_inode(struct task_struct * p,struct inode * inode)1925 void security_task_to_inode(struct task_struct *p, struct inode *inode)
1926 {
1927 call_void_hook(task_to_inode, p, inode);
1928 }
1929
security_ipc_permission(struct kern_ipc_perm * ipcp,short flag)1930 int security_ipc_permission(struct kern_ipc_perm *ipcp, short flag)
1931 {
1932 return call_int_hook(ipc_permission, 0, ipcp, flag);
1933 }
1934
security_ipc_getsecid(struct kern_ipc_perm * ipcp,u32 * secid)1935 void security_ipc_getsecid(struct kern_ipc_perm *ipcp, u32 *secid)
1936 {
1937 *secid = 0;
1938 call_void_hook(ipc_getsecid, ipcp, secid);
1939 }
1940
security_msg_msg_alloc(struct msg_msg * msg)1941 int security_msg_msg_alloc(struct msg_msg *msg)
1942 {
1943 int rc = lsm_msg_msg_alloc(msg);
1944
1945 if (unlikely(rc))
1946 return rc;
1947 rc = call_int_hook(msg_msg_alloc_security, 0, msg);
1948 if (unlikely(rc))
1949 security_msg_msg_free(msg);
1950 return rc;
1951 }
1952
security_msg_msg_free(struct msg_msg * msg)1953 void security_msg_msg_free(struct msg_msg *msg)
1954 {
1955 call_void_hook(msg_msg_free_security, msg);
1956 kfree(msg->security);
1957 msg->security = NULL;
1958 }
1959
security_msg_queue_alloc(struct kern_ipc_perm * msq)1960 int security_msg_queue_alloc(struct kern_ipc_perm *msq)
1961 {
1962 int rc = lsm_ipc_alloc(msq);
1963
1964 if (unlikely(rc))
1965 return rc;
1966 rc = call_int_hook(msg_queue_alloc_security, 0, msq);
1967 if (unlikely(rc))
1968 security_msg_queue_free(msq);
1969 return rc;
1970 }
1971
security_msg_queue_free(struct kern_ipc_perm * msq)1972 void security_msg_queue_free(struct kern_ipc_perm *msq)
1973 {
1974 call_void_hook(msg_queue_free_security, msq);
1975 kfree(msq->security);
1976 msq->security = NULL;
1977 }
1978
security_msg_queue_associate(struct kern_ipc_perm * msq,int msqflg)1979 int security_msg_queue_associate(struct kern_ipc_perm *msq, int msqflg)
1980 {
1981 return call_int_hook(msg_queue_associate, 0, msq, msqflg);
1982 }
1983
security_msg_queue_msgctl(struct kern_ipc_perm * msq,int cmd)1984 int security_msg_queue_msgctl(struct kern_ipc_perm *msq, int cmd)
1985 {
1986 return call_int_hook(msg_queue_msgctl, 0, msq, cmd);
1987 }
1988
security_msg_queue_msgsnd(struct kern_ipc_perm * msq,struct msg_msg * msg,int msqflg)1989 int security_msg_queue_msgsnd(struct kern_ipc_perm *msq,
1990 struct msg_msg *msg, int msqflg)
1991 {
1992 return call_int_hook(msg_queue_msgsnd, 0, msq, msg, msqflg);
1993 }
1994
security_msg_queue_msgrcv(struct kern_ipc_perm * msq,struct msg_msg * msg,struct task_struct * target,long type,int mode)1995 int security_msg_queue_msgrcv(struct kern_ipc_perm *msq, struct msg_msg *msg,
1996 struct task_struct *target, long type, int mode)
1997 {
1998 return call_int_hook(msg_queue_msgrcv, 0, msq, msg, target, type, mode);
1999 }
2000
security_shm_alloc(struct kern_ipc_perm * shp)2001 int security_shm_alloc(struct kern_ipc_perm *shp)
2002 {
2003 int rc = lsm_ipc_alloc(shp);
2004
2005 if (unlikely(rc))
2006 return rc;
2007 rc = call_int_hook(shm_alloc_security, 0, shp);
2008 if (unlikely(rc))
2009 security_shm_free(shp);
2010 return rc;
2011 }
2012
security_shm_free(struct kern_ipc_perm * shp)2013 void security_shm_free(struct kern_ipc_perm *shp)
2014 {
2015 call_void_hook(shm_free_security, shp);
2016 kfree(shp->security);
2017 shp->security = NULL;
2018 }
2019
security_shm_associate(struct kern_ipc_perm * shp,int shmflg)2020 int security_shm_associate(struct kern_ipc_perm *shp, int shmflg)
2021 {
2022 return call_int_hook(shm_associate, 0, shp, shmflg);
2023 }
2024
security_shm_shmctl(struct kern_ipc_perm * shp,int cmd)2025 int security_shm_shmctl(struct kern_ipc_perm *shp, int cmd)
2026 {
2027 return call_int_hook(shm_shmctl, 0, shp, cmd);
2028 }
2029
security_shm_shmat(struct kern_ipc_perm * shp,char __user * shmaddr,int shmflg)2030 int security_shm_shmat(struct kern_ipc_perm *shp, char __user *shmaddr, int shmflg)
2031 {
2032 return call_int_hook(shm_shmat, 0, shp, shmaddr, shmflg);
2033 }
2034
security_sem_alloc(struct kern_ipc_perm * sma)2035 int security_sem_alloc(struct kern_ipc_perm *sma)
2036 {
2037 int rc = lsm_ipc_alloc(sma);
2038
2039 if (unlikely(rc))
2040 return rc;
2041 rc = call_int_hook(sem_alloc_security, 0, sma);
2042 if (unlikely(rc))
2043 security_sem_free(sma);
2044 return rc;
2045 }
2046
security_sem_free(struct kern_ipc_perm * sma)2047 void security_sem_free(struct kern_ipc_perm *sma)
2048 {
2049 call_void_hook(sem_free_security, sma);
2050 kfree(sma->security);
2051 sma->security = NULL;
2052 }
2053
security_sem_associate(struct kern_ipc_perm * sma,int semflg)2054 int security_sem_associate(struct kern_ipc_perm *sma, int semflg)
2055 {
2056 return call_int_hook(sem_associate, 0, sma, semflg);
2057 }
2058
security_sem_semctl(struct kern_ipc_perm * sma,int cmd)2059 int security_sem_semctl(struct kern_ipc_perm *sma, int cmd)
2060 {
2061 return call_int_hook(sem_semctl, 0, sma, cmd);
2062 }
2063
security_sem_semop(struct kern_ipc_perm * sma,struct sembuf * sops,unsigned nsops,int alter)2064 int security_sem_semop(struct kern_ipc_perm *sma, struct sembuf *sops,
2065 unsigned nsops, int alter)
2066 {
2067 return call_int_hook(sem_semop, 0, sma, sops, nsops, alter);
2068 }
2069
security_d_instantiate(struct dentry * dentry,struct inode * inode)2070 void security_d_instantiate(struct dentry *dentry, struct inode *inode)
2071 {
2072 if (unlikely(inode && IS_PRIVATE(inode)))
2073 return;
2074 call_void_hook(d_instantiate, dentry, inode);
2075 }
2076 EXPORT_SYMBOL(security_d_instantiate);
2077
security_getprocattr(struct task_struct * p,const char * lsm,char * name,char ** value)2078 int security_getprocattr(struct task_struct *p, const char *lsm, char *name,
2079 char **value)
2080 {
2081 struct security_hook_list *hp;
2082
2083 hlist_for_each_entry(hp, &security_hook_heads.getprocattr, list) {
2084 if (lsm != NULL && strcmp(lsm, hp->lsm))
2085 continue;
2086 return hp->hook.getprocattr(p, name, value);
2087 }
2088 return LSM_RET_DEFAULT(getprocattr);
2089 }
2090
security_setprocattr(const char * lsm,const char * name,void * value,size_t size)2091 int security_setprocattr(const char *lsm, const char *name, void *value,
2092 size_t size)
2093 {
2094 struct security_hook_list *hp;
2095
2096 hlist_for_each_entry(hp, &security_hook_heads.setprocattr, list) {
2097 if (lsm != NULL && strcmp(lsm, hp->lsm))
2098 continue;
2099 return hp->hook.setprocattr(name, value, size);
2100 }
2101 return LSM_RET_DEFAULT(setprocattr);
2102 }
2103
security_netlink_send(struct sock * sk,struct sk_buff * skb)2104 int security_netlink_send(struct sock *sk, struct sk_buff *skb)
2105 {
2106 return call_int_hook(netlink_send, 0, sk, skb);
2107 }
2108
security_ismaclabel(const char * name)2109 int security_ismaclabel(const char *name)
2110 {
2111 return call_int_hook(ismaclabel, 0, name);
2112 }
2113 EXPORT_SYMBOL(security_ismaclabel);
2114
security_secid_to_secctx(u32 secid,char ** secdata,u32 * seclen)2115 int security_secid_to_secctx(u32 secid, char **secdata, u32 *seclen)
2116 {
2117 struct security_hook_list *hp;
2118 int rc;
2119
2120 /*
2121 * Currently, only one LSM can implement secid_to_secctx (i.e this
2122 * LSM hook is not "stackable").
2123 */
2124 hlist_for_each_entry(hp, &security_hook_heads.secid_to_secctx, list) {
2125 rc = hp->hook.secid_to_secctx(secid, secdata, seclen);
2126 if (rc != LSM_RET_DEFAULT(secid_to_secctx))
2127 return rc;
2128 }
2129
2130 return LSM_RET_DEFAULT(secid_to_secctx);
2131 }
2132 EXPORT_SYMBOL(security_secid_to_secctx);
2133
security_secctx_to_secid(const char * secdata,u32 seclen,u32 * secid)2134 int security_secctx_to_secid(const char *secdata, u32 seclen, u32 *secid)
2135 {
2136 *secid = 0;
2137 return call_int_hook(secctx_to_secid, 0, secdata, seclen, secid);
2138 }
2139 EXPORT_SYMBOL(security_secctx_to_secid);
2140
security_release_secctx(char * secdata,u32 seclen)2141 void security_release_secctx(char *secdata, u32 seclen)
2142 {
2143 call_void_hook(release_secctx, secdata, seclen);
2144 }
2145 EXPORT_SYMBOL(security_release_secctx);
2146
security_inode_invalidate_secctx(struct inode * inode)2147 void security_inode_invalidate_secctx(struct inode *inode)
2148 {
2149 call_void_hook(inode_invalidate_secctx, inode);
2150 }
2151 EXPORT_SYMBOL(security_inode_invalidate_secctx);
2152
security_inode_notifysecctx(struct inode * inode,void * ctx,u32 ctxlen)2153 int security_inode_notifysecctx(struct inode *inode, void *ctx, u32 ctxlen)
2154 {
2155 return call_int_hook(inode_notifysecctx, 0, inode, ctx, ctxlen);
2156 }
2157 EXPORT_SYMBOL(security_inode_notifysecctx);
2158
security_inode_setsecctx(struct dentry * dentry,void * ctx,u32 ctxlen)2159 int security_inode_setsecctx(struct dentry *dentry, void *ctx, u32 ctxlen)
2160 {
2161 return call_int_hook(inode_setsecctx, 0, dentry, ctx, ctxlen);
2162 }
2163 EXPORT_SYMBOL(security_inode_setsecctx);
2164
security_inode_getsecctx(struct inode * inode,void ** ctx,u32 * ctxlen)2165 int security_inode_getsecctx(struct inode *inode, void **ctx, u32 *ctxlen)
2166 {
2167 struct security_hook_list *hp;
2168 int rc;
2169
2170 /*
2171 * Only one module will provide a security context.
2172 */
2173 hlist_for_each_entry(hp, &security_hook_heads.inode_getsecctx, list) {
2174 rc = hp->hook.inode_getsecctx(inode, ctx, ctxlen);
2175 if (rc != LSM_RET_DEFAULT(inode_getsecctx))
2176 return rc;
2177 }
2178
2179 return LSM_RET_DEFAULT(inode_getsecctx);
2180 }
2181 EXPORT_SYMBOL(security_inode_getsecctx);
2182
2183 #ifdef CONFIG_WATCH_QUEUE
security_post_notification(const struct cred * w_cred,const struct cred * cred,struct watch_notification * n)2184 int security_post_notification(const struct cred *w_cred,
2185 const struct cred *cred,
2186 struct watch_notification *n)
2187 {
2188 return call_int_hook(post_notification, 0, w_cred, cred, n);
2189 }
2190 #endif /* CONFIG_WATCH_QUEUE */
2191
2192 #ifdef CONFIG_KEY_NOTIFICATIONS
security_watch_key(struct key * key)2193 int security_watch_key(struct key *key)
2194 {
2195 return call_int_hook(watch_key, 0, key);
2196 }
2197 #endif
2198
2199 #ifdef CONFIG_SECURITY_NETWORK
2200
security_unix_stream_connect(struct sock * sock,struct sock * other,struct sock * newsk)2201 int security_unix_stream_connect(struct sock *sock, struct sock *other, struct sock *newsk)
2202 {
2203 return call_int_hook(unix_stream_connect, 0, sock, other, newsk);
2204 }
2205 EXPORT_SYMBOL(security_unix_stream_connect);
2206
security_unix_may_send(struct socket * sock,struct socket * other)2207 int security_unix_may_send(struct socket *sock, struct socket *other)
2208 {
2209 return call_int_hook(unix_may_send, 0, sock, other);
2210 }
2211 EXPORT_SYMBOL(security_unix_may_send);
2212
security_socket_create(int family,int type,int protocol,int kern)2213 int security_socket_create(int family, int type, int protocol, int kern)
2214 {
2215 return call_int_hook(socket_create, 0, family, type, protocol, kern);
2216 }
2217
security_socket_post_create(struct socket * sock,int family,int type,int protocol,int kern)2218 int security_socket_post_create(struct socket *sock, int family,
2219 int type, int protocol, int kern)
2220 {
2221 return call_int_hook(socket_post_create, 0, sock, family, type,
2222 protocol, kern);
2223 }
2224
security_socket_socketpair(struct socket * socka,struct socket * sockb)2225 int security_socket_socketpair(struct socket *socka, struct socket *sockb)
2226 {
2227 return call_int_hook(socket_socketpair, 0, socka, sockb);
2228 }
2229 EXPORT_SYMBOL(security_socket_socketpair);
2230
security_socket_bind(struct socket * sock,struct sockaddr * address,int addrlen)2231 int security_socket_bind(struct socket *sock, struct sockaddr *address, int addrlen)
2232 {
2233 return call_int_hook(socket_bind, 0, sock, address, addrlen);
2234 }
2235
security_socket_connect(struct socket * sock,struct sockaddr * address,int addrlen)2236 int security_socket_connect(struct socket *sock, struct sockaddr *address, int addrlen)
2237 {
2238 return call_int_hook(socket_connect, 0, sock, address, addrlen);
2239 }
2240
security_socket_listen(struct socket * sock,int backlog)2241 int security_socket_listen(struct socket *sock, int backlog)
2242 {
2243 return call_int_hook(socket_listen, 0, sock, backlog);
2244 }
2245
security_socket_accept(struct socket * sock,struct socket * newsock)2246 int security_socket_accept(struct socket *sock, struct socket *newsock)
2247 {
2248 return call_int_hook(socket_accept, 0, sock, newsock);
2249 }
2250
security_socket_sendmsg(struct socket * sock,struct msghdr * msg,int size)2251 int security_socket_sendmsg(struct socket *sock, struct msghdr *msg, int size)
2252 {
2253 return call_int_hook(socket_sendmsg, 0, sock, msg, size);
2254 }
2255
security_socket_recvmsg(struct socket * sock,struct msghdr * msg,int size,int flags)2256 int security_socket_recvmsg(struct socket *sock, struct msghdr *msg,
2257 int size, int flags)
2258 {
2259 return call_int_hook(socket_recvmsg, 0, sock, msg, size, flags);
2260 }
2261
security_socket_getsockname(struct socket * sock)2262 int security_socket_getsockname(struct socket *sock)
2263 {
2264 return call_int_hook(socket_getsockname, 0, sock);
2265 }
2266
security_socket_getpeername(struct socket * sock)2267 int security_socket_getpeername(struct socket *sock)
2268 {
2269 return call_int_hook(socket_getpeername, 0, sock);
2270 }
2271
security_socket_getsockopt(struct socket * sock,int level,int optname)2272 int security_socket_getsockopt(struct socket *sock, int level, int optname)
2273 {
2274 return call_int_hook(socket_getsockopt, 0, sock, level, optname);
2275 }
2276
security_socket_setsockopt(struct socket * sock,int level,int optname)2277 int security_socket_setsockopt(struct socket *sock, int level, int optname)
2278 {
2279 return call_int_hook(socket_setsockopt, 0, sock, level, optname);
2280 }
2281
security_socket_shutdown(struct socket * sock,int how)2282 int security_socket_shutdown(struct socket *sock, int how)
2283 {
2284 return call_int_hook(socket_shutdown, 0, sock, how);
2285 }
2286
security_sock_rcv_skb(struct sock * sk,struct sk_buff * skb)2287 int security_sock_rcv_skb(struct sock *sk, struct sk_buff *skb)
2288 {
2289 return call_int_hook(socket_sock_rcv_skb, 0, sk, skb);
2290 }
2291 EXPORT_SYMBOL(security_sock_rcv_skb);
2292
security_socket_getpeersec_stream(struct socket * sock,char __user * optval,int __user * optlen,unsigned len)2293 int security_socket_getpeersec_stream(struct socket *sock, char __user *optval,
2294 int __user *optlen, unsigned len)
2295 {
2296 return call_int_hook(socket_getpeersec_stream, -ENOPROTOOPT, sock,
2297 optval, optlen, len);
2298 }
2299
security_socket_getpeersec_dgram(struct socket * sock,struct sk_buff * skb,u32 * secid)2300 int security_socket_getpeersec_dgram(struct socket *sock, struct sk_buff *skb, u32 *secid)
2301 {
2302 return call_int_hook(socket_getpeersec_dgram, -ENOPROTOOPT, sock,
2303 skb, secid);
2304 }
2305 EXPORT_SYMBOL(security_socket_getpeersec_dgram);
2306
security_sk_alloc(struct sock * sk,int family,gfp_t priority)2307 int security_sk_alloc(struct sock *sk, int family, gfp_t priority)
2308 {
2309 return call_int_hook(sk_alloc_security, 0, sk, family, priority);
2310 }
2311
security_sk_free(struct sock * sk)2312 void security_sk_free(struct sock *sk)
2313 {
2314 call_void_hook(sk_free_security, sk);
2315 }
2316
security_sk_clone(const struct sock * sk,struct sock * newsk)2317 void security_sk_clone(const struct sock *sk, struct sock *newsk)
2318 {
2319 call_void_hook(sk_clone_security, sk, newsk);
2320 }
2321 EXPORT_SYMBOL(security_sk_clone);
2322
security_sk_classify_flow(struct sock * sk,struct flowi_common * flic)2323 void security_sk_classify_flow(struct sock *sk, struct flowi_common *flic)
2324 {
2325 call_void_hook(sk_getsecid, sk, &flic->flowic_secid);
2326 }
2327 EXPORT_SYMBOL(security_sk_classify_flow);
2328
security_req_classify_flow(const struct request_sock * req,struct flowi_common * flic)2329 void security_req_classify_flow(const struct request_sock *req,
2330 struct flowi_common *flic)
2331 {
2332 call_void_hook(req_classify_flow, req, flic);
2333 }
2334 EXPORT_SYMBOL(security_req_classify_flow);
2335
security_sock_graft(struct sock * sk,struct socket * parent)2336 void security_sock_graft(struct sock *sk, struct socket *parent)
2337 {
2338 call_void_hook(sock_graft, sk, parent);
2339 }
2340 EXPORT_SYMBOL(security_sock_graft);
2341
security_inet_conn_request(const struct sock * sk,struct sk_buff * skb,struct request_sock * req)2342 int security_inet_conn_request(const struct sock *sk,
2343 struct sk_buff *skb, struct request_sock *req)
2344 {
2345 return call_int_hook(inet_conn_request, 0, sk, skb, req);
2346 }
2347 EXPORT_SYMBOL(security_inet_conn_request);
2348
security_inet_csk_clone(struct sock * newsk,const struct request_sock * req)2349 void security_inet_csk_clone(struct sock *newsk,
2350 const struct request_sock *req)
2351 {
2352 call_void_hook(inet_csk_clone, newsk, req);
2353 }
2354
security_inet_conn_established(struct sock * sk,struct sk_buff * skb)2355 void security_inet_conn_established(struct sock *sk,
2356 struct sk_buff *skb)
2357 {
2358 call_void_hook(inet_conn_established, sk, skb);
2359 }
2360 EXPORT_SYMBOL(security_inet_conn_established);
2361
security_secmark_relabel_packet(u32 secid)2362 int security_secmark_relabel_packet(u32 secid)
2363 {
2364 return call_int_hook(secmark_relabel_packet, 0, secid);
2365 }
2366 EXPORT_SYMBOL(security_secmark_relabel_packet);
2367
security_secmark_refcount_inc(void)2368 void security_secmark_refcount_inc(void)
2369 {
2370 call_void_hook(secmark_refcount_inc);
2371 }
2372 EXPORT_SYMBOL(security_secmark_refcount_inc);
2373
security_secmark_refcount_dec(void)2374 void security_secmark_refcount_dec(void)
2375 {
2376 call_void_hook(secmark_refcount_dec);
2377 }
2378 EXPORT_SYMBOL(security_secmark_refcount_dec);
2379
security_tun_dev_alloc_security(void ** security)2380 int security_tun_dev_alloc_security(void **security)
2381 {
2382 return call_int_hook(tun_dev_alloc_security, 0, security);
2383 }
2384 EXPORT_SYMBOL(security_tun_dev_alloc_security);
2385
security_tun_dev_free_security(void * security)2386 void security_tun_dev_free_security(void *security)
2387 {
2388 call_void_hook(tun_dev_free_security, security);
2389 }
2390 EXPORT_SYMBOL(security_tun_dev_free_security);
2391
security_tun_dev_create(void)2392 int security_tun_dev_create(void)
2393 {
2394 return call_int_hook(tun_dev_create, 0);
2395 }
2396 EXPORT_SYMBOL(security_tun_dev_create);
2397
security_tun_dev_attach_queue(void * security)2398 int security_tun_dev_attach_queue(void *security)
2399 {
2400 return call_int_hook(tun_dev_attach_queue, 0, security);
2401 }
2402 EXPORT_SYMBOL(security_tun_dev_attach_queue);
2403
security_tun_dev_attach(struct sock * sk,void * security)2404 int security_tun_dev_attach(struct sock *sk, void *security)
2405 {
2406 return call_int_hook(tun_dev_attach, 0, sk, security);
2407 }
2408 EXPORT_SYMBOL(security_tun_dev_attach);
2409
security_tun_dev_open(void * security)2410 int security_tun_dev_open(void *security)
2411 {
2412 return call_int_hook(tun_dev_open, 0, security);
2413 }
2414 EXPORT_SYMBOL(security_tun_dev_open);
2415
security_sctp_assoc_request(struct sctp_endpoint * ep,struct sk_buff * skb)2416 int security_sctp_assoc_request(struct sctp_endpoint *ep, struct sk_buff *skb)
2417 {
2418 return call_int_hook(sctp_assoc_request, 0, ep, skb);
2419 }
2420 EXPORT_SYMBOL(security_sctp_assoc_request);
2421
security_sctp_bind_connect(struct sock * sk,int optname,struct sockaddr * address,int addrlen)2422 int security_sctp_bind_connect(struct sock *sk, int optname,
2423 struct sockaddr *address, int addrlen)
2424 {
2425 return call_int_hook(sctp_bind_connect, 0, sk, optname,
2426 address, addrlen);
2427 }
2428 EXPORT_SYMBOL(security_sctp_bind_connect);
2429
security_sctp_sk_clone(struct sctp_endpoint * ep,struct sock * sk,struct sock * newsk)2430 void security_sctp_sk_clone(struct sctp_endpoint *ep, struct sock *sk,
2431 struct sock *newsk)
2432 {
2433 call_void_hook(sctp_sk_clone, ep, sk, newsk);
2434 }
2435 EXPORT_SYMBOL(security_sctp_sk_clone);
2436
2437 #endif /* CONFIG_SECURITY_NETWORK */
2438
2439 #ifdef CONFIG_SECURITY_INFINIBAND
2440
security_ib_pkey_access(void * sec,u64 subnet_prefix,u16 pkey)2441 int security_ib_pkey_access(void *sec, u64 subnet_prefix, u16 pkey)
2442 {
2443 return call_int_hook(ib_pkey_access, 0, sec, subnet_prefix, pkey);
2444 }
2445 EXPORT_SYMBOL(security_ib_pkey_access);
2446
security_ib_endport_manage_subnet(void * sec,const char * dev_name,u8 port_num)2447 int security_ib_endport_manage_subnet(void *sec, const char *dev_name, u8 port_num)
2448 {
2449 return call_int_hook(ib_endport_manage_subnet, 0, sec, dev_name, port_num);
2450 }
2451 EXPORT_SYMBOL(security_ib_endport_manage_subnet);
2452
security_ib_alloc_security(void ** sec)2453 int security_ib_alloc_security(void **sec)
2454 {
2455 return call_int_hook(ib_alloc_security, 0, sec);
2456 }
2457 EXPORT_SYMBOL(security_ib_alloc_security);
2458
security_ib_free_security(void * sec)2459 void security_ib_free_security(void *sec)
2460 {
2461 call_void_hook(ib_free_security, sec);
2462 }
2463 EXPORT_SYMBOL(security_ib_free_security);
2464 #endif /* CONFIG_SECURITY_INFINIBAND */
2465
2466 #ifdef CONFIG_SECURITY_NETWORK_XFRM
2467
security_xfrm_policy_alloc(struct xfrm_sec_ctx ** ctxp,struct xfrm_user_sec_ctx * sec_ctx,gfp_t gfp)2468 int security_xfrm_policy_alloc(struct xfrm_sec_ctx **ctxp,
2469 struct xfrm_user_sec_ctx *sec_ctx,
2470 gfp_t gfp)
2471 {
2472 return call_int_hook(xfrm_policy_alloc_security, 0, ctxp, sec_ctx, gfp);
2473 }
2474 EXPORT_SYMBOL(security_xfrm_policy_alloc);
2475
security_xfrm_policy_clone(struct xfrm_sec_ctx * old_ctx,struct xfrm_sec_ctx ** new_ctxp)2476 int security_xfrm_policy_clone(struct xfrm_sec_ctx *old_ctx,
2477 struct xfrm_sec_ctx **new_ctxp)
2478 {
2479 return call_int_hook(xfrm_policy_clone_security, 0, old_ctx, new_ctxp);
2480 }
2481
security_xfrm_policy_free(struct xfrm_sec_ctx * ctx)2482 void security_xfrm_policy_free(struct xfrm_sec_ctx *ctx)
2483 {
2484 call_void_hook(xfrm_policy_free_security, ctx);
2485 }
2486 EXPORT_SYMBOL(security_xfrm_policy_free);
2487
security_xfrm_policy_delete(struct xfrm_sec_ctx * ctx)2488 int security_xfrm_policy_delete(struct xfrm_sec_ctx *ctx)
2489 {
2490 return call_int_hook(xfrm_policy_delete_security, 0, ctx);
2491 }
2492
security_xfrm_state_alloc(struct xfrm_state * x,struct xfrm_user_sec_ctx * sec_ctx)2493 int security_xfrm_state_alloc(struct xfrm_state *x,
2494 struct xfrm_user_sec_ctx *sec_ctx)
2495 {
2496 return call_int_hook(xfrm_state_alloc, 0, x, sec_ctx);
2497 }
2498 EXPORT_SYMBOL(security_xfrm_state_alloc);
2499
security_xfrm_state_alloc_acquire(struct xfrm_state * x,struct xfrm_sec_ctx * polsec,u32 secid)2500 int security_xfrm_state_alloc_acquire(struct xfrm_state *x,
2501 struct xfrm_sec_ctx *polsec, u32 secid)
2502 {
2503 return call_int_hook(xfrm_state_alloc_acquire, 0, x, polsec, secid);
2504 }
2505
security_xfrm_state_delete(struct xfrm_state * x)2506 int security_xfrm_state_delete(struct xfrm_state *x)
2507 {
2508 return call_int_hook(xfrm_state_delete_security, 0, x);
2509 }
2510 EXPORT_SYMBOL(security_xfrm_state_delete);
2511
security_xfrm_state_free(struct xfrm_state * x)2512 void security_xfrm_state_free(struct xfrm_state *x)
2513 {
2514 call_void_hook(xfrm_state_free_security, x);
2515 }
2516
security_xfrm_policy_lookup(struct xfrm_sec_ctx * ctx,u32 fl_secid)2517 int security_xfrm_policy_lookup(struct xfrm_sec_ctx *ctx, u32 fl_secid)
2518 {
2519 return call_int_hook(xfrm_policy_lookup, 0, ctx, fl_secid);
2520 }
2521
security_xfrm_state_pol_flow_match(struct xfrm_state * x,struct xfrm_policy * xp,const struct flowi_common * flic)2522 int security_xfrm_state_pol_flow_match(struct xfrm_state *x,
2523 struct xfrm_policy *xp,
2524 const struct flowi_common *flic)
2525 {
2526 struct security_hook_list *hp;
2527 int rc = LSM_RET_DEFAULT(xfrm_state_pol_flow_match);
2528
2529 /*
2530 * Since this function is expected to return 0 or 1, the judgment
2531 * becomes difficult if multiple LSMs supply this call. Fortunately,
2532 * we can use the first LSM's judgment because currently only SELinux
2533 * supplies this call.
2534 *
2535 * For speed optimization, we explicitly break the loop rather than
2536 * using the macro
2537 */
2538 hlist_for_each_entry(hp, &security_hook_heads.xfrm_state_pol_flow_match,
2539 list) {
2540 rc = hp->hook.xfrm_state_pol_flow_match(x, xp, flic);
2541 break;
2542 }
2543 return rc;
2544 }
2545
security_xfrm_decode_session(struct sk_buff * skb,u32 * secid)2546 int security_xfrm_decode_session(struct sk_buff *skb, u32 *secid)
2547 {
2548 return call_int_hook(xfrm_decode_session, 0, skb, secid, 1);
2549 }
2550
security_skb_classify_flow(struct sk_buff * skb,struct flowi_common * flic)2551 void security_skb_classify_flow(struct sk_buff *skb, struct flowi_common *flic)
2552 {
2553 int rc = call_int_hook(xfrm_decode_session, 0, skb, &flic->flowic_secid,
2554 0);
2555
2556 BUG_ON(rc);
2557 }
2558 EXPORT_SYMBOL(security_skb_classify_flow);
2559
2560 #endif /* CONFIG_SECURITY_NETWORK_XFRM */
2561
2562 #ifdef CONFIG_KEYS
2563
security_key_alloc(struct key * key,const struct cred * cred,unsigned long flags)2564 int security_key_alloc(struct key *key, const struct cred *cred,
2565 unsigned long flags)
2566 {
2567 return call_int_hook(key_alloc, 0, key, cred, flags);
2568 }
2569
security_key_free(struct key * key)2570 void security_key_free(struct key *key)
2571 {
2572 call_void_hook(key_free, key);
2573 }
2574
security_key_permission(key_ref_t key_ref,const struct cred * cred,enum key_need_perm need_perm)2575 int security_key_permission(key_ref_t key_ref, const struct cred *cred,
2576 enum key_need_perm need_perm)
2577 {
2578 return call_int_hook(key_permission, 0, key_ref, cred, need_perm);
2579 }
2580
security_key_getsecurity(struct key * key,char ** _buffer)2581 int security_key_getsecurity(struct key *key, char **_buffer)
2582 {
2583 *_buffer = NULL;
2584 return call_int_hook(key_getsecurity, 0, key, _buffer);
2585 }
2586
2587 #endif /* CONFIG_KEYS */
2588
2589 #ifdef CONFIG_AUDIT
2590
security_audit_rule_init(u32 field,u32 op,char * rulestr,void ** lsmrule)2591 int security_audit_rule_init(u32 field, u32 op, char *rulestr, void **lsmrule)
2592 {
2593 return call_int_hook(audit_rule_init, 0, field, op, rulestr, lsmrule);
2594 }
2595
security_audit_rule_known(struct audit_krule * krule)2596 int security_audit_rule_known(struct audit_krule *krule)
2597 {
2598 return call_int_hook(audit_rule_known, 0, krule);
2599 }
2600
security_audit_rule_free(void * lsmrule)2601 void security_audit_rule_free(void *lsmrule)
2602 {
2603 call_void_hook(audit_rule_free, lsmrule);
2604 }
2605
security_audit_rule_match(u32 secid,u32 field,u32 op,void * lsmrule)2606 int security_audit_rule_match(u32 secid, u32 field, u32 op, void *lsmrule)
2607 {
2608 return call_int_hook(audit_rule_match, 0, secid, field, op, lsmrule);
2609 }
2610 #endif /* CONFIG_AUDIT */
2611
2612 #ifdef CONFIG_BPF_SYSCALL
security_bpf(int cmd,union bpf_attr * attr,unsigned int size)2613 int security_bpf(int cmd, union bpf_attr *attr, unsigned int size)
2614 {
2615 return call_int_hook(bpf, 0, cmd, attr, size);
2616 }
security_bpf_map(struct bpf_map * map,fmode_t fmode)2617 int security_bpf_map(struct bpf_map *map, fmode_t fmode)
2618 {
2619 return call_int_hook(bpf_map, 0, map, fmode);
2620 }
security_bpf_prog(struct bpf_prog * prog)2621 int security_bpf_prog(struct bpf_prog *prog)
2622 {
2623 return call_int_hook(bpf_prog, 0, prog);
2624 }
security_bpf_map_alloc(struct bpf_map * map)2625 int security_bpf_map_alloc(struct bpf_map *map)
2626 {
2627 return call_int_hook(bpf_map_alloc_security, 0, map);
2628 }
security_bpf_prog_alloc(struct bpf_prog_aux * aux)2629 int security_bpf_prog_alloc(struct bpf_prog_aux *aux)
2630 {
2631 return call_int_hook(bpf_prog_alloc_security, 0, aux);
2632 }
security_bpf_map_free(struct bpf_map * map)2633 void security_bpf_map_free(struct bpf_map *map)
2634 {
2635 call_void_hook(bpf_map_free_security, map);
2636 }
security_bpf_prog_free(struct bpf_prog_aux * aux)2637 void security_bpf_prog_free(struct bpf_prog_aux *aux)
2638 {
2639 call_void_hook(bpf_prog_free_security, aux);
2640 }
2641 #endif /* CONFIG_BPF_SYSCALL */
2642
security_locked_down(enum lockdown_reason what)2643 int security_locked_down(enum lockdown_reason what)
2644 {
2645 return call_int_hook(locked_down, 0, what);
2646 }
2647 EXPORT_SYMBOL(security_locked_down);
2648
2649 #ifdef CONFIG_PERF_EVENTS
security_perf_event_open(struct perf_event_attr * attr,int type)2650 int security_perf_event_open(struct perf_event_attr *attr, int type)
2651 {
2652 return call_int_hook(perf_event_open, 0, attr, type);
2653 }
2654
security_perf_event_alloc(struct perf_event * event)2655 int security_perf_event_alloc(struct perf_event *event)
2656 {
2657 return call_int_hook(perf_event_alloc, 0, event);
2658 }
2659
security_perf_event_free(struct perf_event * event)2660 void security_perf_event_free(struct perf_event *event)
2661 {
2662 call_void_hook(perf_event_free, event);
2663 }
2664
security_perf_event_read(struct perf_event * event)2665 int security_perf_event_read(struct perf_event *event)
2666 {
2667 return call_int_hook(perf_event_read, 0, event);
2668 }
2669
security_perf_event_write(struct perf_event * event)2670 int security_perf_event_write(struct perf_event *event)
2671 {
2672 return call_int_hook(perf_event_write, 0, event);
2673 }
2674 #endif /* CONFIG_PERF_EVENTS */
2675