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