1 /* 2 * Simplified MAC Kernel (smack) security module 3 * 4 * This file contains the smack hook function implementations. 5 * 6 * Authors: 7 * Casey Schaufler <casey@schaufler-ca.com> 8 * Jarkko Sakkinen <jarkko.sakkinen@intel.com> 9 * 10 * Copyright (C) 2007 Casey Schaufler <casey@schaufler-ca.com> 11 * Copyright (C) 2009 Hewlett-Packard Development Company, L.P. 12 * Paul Moore <paul@paul-moore.com> 13 * Copyright (C) 2010 Nokia Corporation 14 * Copyright (C) 2011 Intel Corporation. 15 * 16 * This program is free software; you can redistribute it and/or modify 17 * it under the terms of the GNU General Public License version 2, 18 * as published by the Free Software Foundation. 19 */ 20 21 #include <linux/xattr.h> 22 #include <linux/pagemap.h> 23 #include <linux/mount.h> 24 #include <linux/stat.h> 25 #include <linux/kd.h> 26 #include <asm/ioctls.h> 27 #include <linux/ip.h> 28 #include <linux/tcp.h> 29 #include <linux/udp.h> 30 #include <linux/dccp.h> 31 #include <linux/slab.h> 32 #include <linux/mutex.h> 33 #include <linux/pipe_fs_i.h> 34 #include <net/cipso_ipv4.h> 35 #include <net/ip.h> 36 #include <net/ipv6.h> 37 #include <linux/audit.h> 38 #include <linux/magic.h> 39 #include <linux/dcache.h> 40 #include <linux/personality.h> 41 #include <linux/msg.h> 42 #include <linux/shm.h> 43 #include <linux/binfmts.h> 44 #include "smack.h" 45 46 #define task_security(task) (task_cred_xxx((task), security)) 47 48 #define TRANS_TRUE "TRUE" 49 #define TRANS_TRUE_SIZE 4 50 51 #define SMK_CONNECTING 0 52 #define SMK_RECEIVING 1 53 #define SMK_SENDING 2 54 55 LIST_HEAD(smk_ipv6_port_list); 56 57 /** 58 * smk_fetch - Fetch the smack label from a file. 59 * @ip: a pointer to the inode 60 * @dp: a pointer to the dentry 61 * 62 * Returns a pointer to the master list entry for the Smack label 63 * or NULL if there was no label to fetch. 64 */ 65 static struct smack_known *smk_fetch(const char *name, struct inode *ip, 66 struct dentry *dp) 67 { 68 int rc; 69 char *buffer; 70 struct smack_known *skp = NULL; 71 72 if (ip->i_op->getxattr == NULL) 73 return NULL; 74 75 buffer = kzalloc(SMK_LONGLABEL, GFP_KERNEL); 76 if (buffer == NULL) 77 return NULL; 78 79 rc = ip->i_op->getxattr(dp, name, buffer, SMK_LONGLABEL); 80 if (rc > 0) 81 skp = smk_import_entry(buffer, rc); 82 83 kfree(buffer); 84 85 return skp; 86 } 87 88 /** 89 * new_inode_smack - allocate an inode security blob 90 * @smack: a pointer to the Smack label to use in the blob 91 * 92 * Returns the new blob or NULL if there's no memory available 93 */ 94 struct inode_smack *new_inode_smack(char *smack) 95 { 96 struct inode_smack *isp; 97 98 isp = kzalloc(sizeof(struct inode_smack), GFP_NOFS); 99 if (isp == NULL) 100 return NULL; 101 102 isp->smk_inode = smack; 103 isp->smk_flags = 0; 104 mutex_init(&isp->smk_lock); 105 106 return isp; 107 } 108 109 /** 110 * new_task_smack - allocate a task security blob 111 * @smack: a pointer to the Smack label to use in the blob 112 * 113 * Returns the new blob or NULL if there's no memory available 114 */ 115 static struct task_smack *new_task_smack(struct smack_known *task, 116 struct smack_known *forked, gfp_t gfp) 117 { 118 struct task_smack *tsp; 119 120 tsp = kzalloc(sizeof(struct task_smack), gfp); 121 if (tsp == NULL) 122 return NULL; 123 124 tsp->smk_task = task; 125 tsp->smk_forked = forked; 126 INIT_LIST_HEAD(&tsp->smk_rules); 127 mutex_init(&tsp->smk_rules_lock); 128 129 return tsp; 130 } 131 132 /** 133 * smk_copy_rules - copy a rule set 134 * @nhead - new rules header pointer 135 * @ohead - old rules header pointer 136 * 137 * Returns 0 on success, -ENOMEM on error 138 */ 139 static int smk_copy_rules(struct list_head *nhead, struct list_head *ohead, 140 gfp_t gfp) 141 { 142 struct smack_rule *nrp; 143 struct smack_rule *orp; 144 int rc = 0; 145 146 INIT_LIST_HEAD(nhead); 147 148 list_for_each_entry_rcu(orp, ohead, list) { 149 nrp = kzalloc(sizeof(struct smack_rule), gfp); 150 if (nrp == NULL) { 151 rc = -ENOMEM; 152 break; 153 } 154 *nrp = *orp; 155 list_add_rcu(&nrp->list, nhead); 156 } 157 return rc; 158 } 159 160 /* 161 * LSM hooks. 162 * We he, that is fun! 163 */ 164 165 /** 166 * smack_ptrace_access_check - Smack approval on PTRACE_ATTACH 167 * @ctp: child task pointer 168 * @mode: ptrace attachment mode 169 * 170 * Returns 0 if access is OK, an error code otherwise 171 * 172 * Do the capability checks, and require read and write. 173 */ 174 static int smack_ptrace_access_check(struct task_struct *ctp, unsigned int mode) 175 { 176 int rc; 177 struct smk_audit_info ad; 178 struct smack_known *skp; 179 180 rc = cap_ptrace_access_check(ctp, mode); 181 if (rc != 0) 182 return rc; 183 184 skp = smk_of_task(task_security(ctp)); 185 smk_ad_init(&ad, __func__, LSM_AUDIT_DATA_TASK); 186 smk_ad_setfield_u_tsk(&ad, ctp); 187 188 rc = smk_curacc(skp->smk_known, MAY_READWRITE, &ad); 189 return rc; 190 } 191 192 /** 193 * smack_ptrace_traceme - Smack approval on PTRACE_TRACEME 194 * @ptp: parent task pointer 195 * 196 * Returns 0 if access is OK, an error code otherwise 197 * 198 * Do the capability checks, and require read and write. 199 */ 200 static int smack_ptrace_traceme(struct task_struct *ptp) 201 { 202 int rc; 203 struct smk_audit_info ad; 204 struct smack_known *skp; 205 206 rc = cap_ptrace_traceme(ptp); 207 if (rc != 0) 208 return rc; 209 210 skp = smk_of_task(task_security(ptp)); 211 smk_ad_init(&ad, __func__, LSM_AUDIT_DATA_TASK); 212 smk_ad_setfield_u_tsk(&ad, ptp); 213 214 rc = smk_curacc(skp->smk_known, MAY_READWRITE, &ad); 215 return rc; 216 } 217 218 /** 219 * smack_syslog - Smack approval on syslog 220 * @type: message type 221 * 222 * Require that the task has the floor label 223 * 224 * Returns 0 on success, error code otherwise. 225 */ 226 static int smack_syslog(int typefrom_file) 227 { 228 int rc = 0; 229 struct smack_known *skp = smk_of_current(); 230 231 if (smack_privileged(CAP_MAC_OVERRIDE)) 232 return 0; 233 234 if (skp != &smack_known_floor) 235 rc = -EACCES; 236 237 return rc; 238 } 239 240 241 /* 242 * Superblock Hooks. 243 */ 244 245 /** 246 * smack_sb_alloc_security - allocate a superblock blob 247 * @sb: the superblock getting the blob 248 * 249 * Returns 0 on success or -ENOMEM on error. 250 */ 251 static int smack_sb_alloc_security(struct super_block *sb) 252 { 253 struct superblock_smack *sbsp; 254 255 sbsp = kzalloc(sizeof(struct superblock_smack), GFP_KERNEL); 256 257 if (sbsp == NULL) 258 return -ENOMEM; 259 260 sbsp->smk_root = smack_known_floor.smk_known; 261 sbsp->smk_default = smack_known_floor.smk_known; 262 sbsp->smk_floor = smack_known_floor.smk_known; 263 sbsp->smk_hat = smack_known_hat.smk_known; 264 /* 265 * smk_initialized will be zero from kzalloc. 266 */ 267 sb->s_security = sbsp; 268 269 return 0; 270 } 271 272 /** 273 * smack_sb_free_security - free a superblock blob 274 * @sb: the superblock getting the blob 275 * 276 */ 277 static void smack_sb_free_security(struct super_block *sb) 278 { 279 kfree(sb->s_security); 280 sb->s_security = NULL; 281 } 282 283 /** 284 * smack_sb_copy_data - copy mount options data for processing 285 * @orig: where to start 286 * @smackopts: mount options string 287 * 288 * Returns 0 on success or -ENOMEM on error. 289 * 290 * Copy the Smack specific mount options out of the mount 291 * options list. 292 */ 293 static int smack_sb_copy_data(char *orig, char *smackopts) 294 { 295 char *cp, *commap, *otheropts, *dp; 296 297 otheropts = (char *)get_zeroed_page(GFP_KERNEL); 298 if (otheropts == NULL) 299 return -ENOMEM; 300 301 for (cp = orig, commap = orig; commap != NULL; cp = commap + 1) { 302 if (strstr(cp, SMK_FSDEFAULT) == cp) 303 dp = smackopts; 304 else if (strstr(cp, SMK_FSFLOOR) == cp) 305 dp = smackopts; 306 else if (strstr(cp, SMK_FSHAT) == cp) 307 dp = smackopts; 308 else if (strstr(cp, SMK_FSROOT) == cp) 309 dp = smackopts; 310 else if (strstr(cp, SMK_FSTRANS) == cp) 311 dp = smackopts; 312 else 313 dp = otheropts; 314 315 commap = strchr(cp, ','); 316 if (commap != NULL) 317 *commap = '\0'; 318 319 if (*dp != '\0') 320 strcat(dp, ","); 321 strcat(dp, cp); 322 } 323 324 strcpy(orig, otheropts); 325 free_page((unsigned long)otheropts); 326 327 return 0; 328 } 329 330 /** 331 * smack_sb_kern_mount - Smack specific mount processing 332 * @sb: the file system superblock 333 * @flags: the mount flags 334 * @data: the smack mount options 335 * 336 * Returns 0 on success, an error code on failure 337 */ 338 static int smack_sb_kern_mount(struct super_block *sb, int flags, void *data) 339 { 340 struct dentry *root = sb->s_root; 341 struct inode *inode = root->d_inode; 342 struct superblock_smack *sp = sb->s_security; 343 struct inode_smack *isp; 344 char *op; 345 char *commap; 346 char *nsp; 347 int transmute = 0; 348 349 if (sp->smk_initialized) 350 return 0; 351 352 sp->smk_initialized = 1; 353 354 for (op = data; op != NULL; op = commap) { 355 commap = strchr(op, ','); 356 if (commap != NULL) 357 *commap++ = '\0'; 358 359 if (strncmp(op, SMK_FSHAT, strlen(SMK_FSHAT)) == 0) { 360 op += strlen(SMK_FSHAT); 361 nsp = smk_import(op, 0); 362 if (nsp != NULL) 363 sp->smk_hat = nsp; 364 } else if (strncmp(op, SMK_FSFLOOR, strlen(SMK_FSFLOOR)) == 0) { 365 op += strlen(SMK_FSFLOOR); 366 nsp = smk_import(op, 0); 367 if (nsp != NULL) 368 sp->smk_floor = nsp; 369 } else if (strncmp(op, SMK_FSDEFAULT, 370 strlen(SMK_FSDEFAULT)) == 0) { 371 op += strlen(SMK_FSDEFAULT); 372 nsp = smk_import(op, 0); 373 if (nsp != NULL) 374 sp->smk_default = nsp; 375 } else if (strncmp(op, SMK_FSROOT, strlen(SMK_FSROOT)) == 0) { 376 op += strlen(SMK_FSROOT); 377 nsp = smk_import(op, 0); 378 if (nsp != NULL) 379 sp->smk_root = nsp; 380 } else if (strncmp(op, SMK_FSTRANS, strlen(SMK_FSTRANS)) == 0) { 381 op += strlen(SMK_FSTRANS); 382 nsp = smk_import(op, 0); 383 if (nsp != NULL) { 384 sp->smk_root = nsp; 385 transmute = 1; 386 } 387 } 388 } 389 390 /* 391 * Initialize the root inode. 392 */ 393 isp = inode->i_security; 394 if (inode->i_security == NULL) { 395 inode->i_security = new_inode_smack(sp->smk_root); 396 isp = inode->i_security; 397 } else 398 isp->smk_inode = sp->smk_root; 399 400 if (transmute) 401 isp->smk_flags |= SMK_INODE_TRANSMUTE; 402 403 return 0; 404 } 405 406 /** 407 * smack_sb_statfs - Smack check on statfs 408 * @dentry: identifies the file system in question 409 * 410 * Returns 0 if current can read the floor of the filesystem, 411 * and error code otherwise 412 */ 413 static int smack_sb_statfs(struct dentry *dentry) 414 { 415 struct superblock_smack *sbp = dentry->d_sb->s_security; 416 int rc; 417 struct smk_audit_info ad; 418 419 smk_ad_init(&ad, __func__, LSM_AUDIT_DATA_DENTRY); 420 smk_ad_setfield_u_fs_path_dentry(&ad, dentry); 421 422 rc = smk_curacc(sbp->smk_floor, MAY_READ, &ad); 423 return rc; 424 } 425 426 /** 427 * smack_sb_mount - Smack check for mounting 428 * @dev_name: unused 429 * @path: mount point 430 * @type: unused 431 * @flags: unused 432 * @data: unused 433 * 434 * Returns 0 if current can write the floor of the filesystem 435 * being mounted on, an error code otherwise. 436 */ 437 static int smack_sb_mount(const char *dev_name, struct path *path, 438 const char *type, unsigned long flags, void *data) 439 { 440 struct superblock_smack *sbp = path->dentry->d_sb->s_security; 441 struct smk_audit_info ad; 442 443 smk_ad_init(&ad, __func__, LSM_AUDIT_DATA_PATH); 444 smk_ad_setfield_u_fs_path(&ad, *path); 445 446 return smk_curacc(sbp->smk_floor, MAY_WRITE, &ad); 447 } 448 449 /** 450 * smack_sb_umount - Smack check for unmounting 451 * @mnt: file system to unmount 452 * @flags: unused 453 * 454 * Returns 0 if current can write the floor of the filesystem 455 * being unmounted, an error code otherwise. 456 */ 457 static int smack_sb_umount(struct vfsmount *mnt, int flags) 458 { 459 struct superblock_smack *sbp; 460 struct smk_audit_info ad; 461 struct path path; 462 463 path.dentry = mnt->mnt_root; 464 path.mnt = mnt; 465 466 smk_ad_init(&ad, __func__, LSM_AUDIT_DATA_PATH); 467 smk_ad_setfield_u_fs_path(&ad, path); 468 469 sbp = path.dentry->d_sb->s_security; 470 return smk_curacc(sbp->smk_floor, MAY_WRITE, &ad); 471 } 472 473 /* 474 * BPRM hooks 475 */ 476 477 /** 478 * smack_bprm_set_creds - set creds for exec 479 * @bprm: the exec information 480 * 481 * Returns 0 if it gets a blob, -ENOMEM otherwise 482 */ 483 static int smack_bprm_set_creds(struct linux_binprm *bprm) 484 { 485 struct inode *inode = file_inode(bprm->file); 486 struct task_smack *bsp = bprm->cred->security; 487 struct inode_smack *isp; 488 int rc; 489 490 rc = cap_bprm_set_creds(bprm); 491 if (rc != 0) 492 return rc; 493 494 if (bprm->cred_prepared) 495 return 0; 496 497 isp = inode->i_security; 498 if (isp->smk_task == NULL || isp->smk_task == bsp->smk_task) 499 return 0; 500 501 if (bprm->unsafe) 502 return -EPERM; 503 504 bsp->smk_task = isp->smk_task; 505 bprm->per_clear |= PER_CLEAR_ON_SETID; 506 507 return 0; 508 } 509 510 /** 511 * smack_bprm_committing_creds - Prepare to install the new credentials 512 * from bprm. 513 * 514 * @bprm: binprm for exec 515 */ 516 static void smack_bprm_committing_creds(struct linux_binprm *bprm) 517 { 518 struct task_smack *bsp = bprm->cred->security; 519 520 if (bsp->smk_task != bsp->smk_forked) 521 current->pdeath_signal = 0; 522 } 523 524 /** 525 * smack_bprm_secureexec - Return the decision to use secureexec. 526 * @bprm: binprm for exec 527 * 528 * Returns 0 on success. 529 */ 530 static int smack_bprm_secureexec(struct linux_binprm *bprm) 531 { 532 struct task_smack *tsp = current_security(); 533 int ret = cap_bprm_secureexec(bprm); 534 535 if (!ret && (tsp->smk_task != tsp->smk_forked)) 536 ret = 1; 537 538 return ret; 539 } 540 541 /* 542 * Inode hooks 543 */ 544 545 /** 546 * smack_inode_alloc_security - allocate an inode blob 547 * @inode: the inode in need of a blob 548 * 549 * Returns 0 if it gets a blob, -ENOMEM otherwise 550 */ 551 static int smack_inode_alloc_security(struct inode *inode) 552 { 553 struct smack_known *skp = smk_of_current(); 554 555 inode->i_security = new_inode_smack(skp->smk_known); 556 if (inode->i_security == NULL) 557 return -ENOMEM; 558 return 0; 559 } 560 561 /** 562 * smack_inode_free_security - free an inode blob 563 * @inode: the inode with a blob 564 * 565 * Clears the blob pointer in inode 566 */ 567 static void smack_inode_free_security(struct inode *inode) 568 { 569 kfree(inode->i_security); 570 inode->i_security = NULL; 571 } 572 573 /** 574 * smack_inode_init_security - copy out the smack from an inode 575 * @inode: the inode 576 * @dir: unused 577 * @qstr: unused 578 * @name: where to put the attribute name 579 * @value: where to put the attribute value 580 * @len: where to put the length of the attribute 581 * 582 * Returns 0 if it all works out, -ENOMEM if there's no memory 583 */ 584 static int smack_inode_init_security(struct inode *inode, struct inode *dir, 585 const struct qstr *qstr, char **name, 586 void **value, size_t *len) 587 { 588 struct inode_smack *issp = inode->i_security; 589 struct smack_known *skp = smk_of_current(); 590 char *isp = smk_of_inode(inode); 591 char *dsp = smk_of_inode(dir); 592 int may; 593 594 if (name) { 595 *name = kstrdup(XATTR_SMACK_SUFFIX, GFP_NOFS); 596 if (*name == NULL) 597 return -ENOMEM; 598 } 599 600 if (value) { 601 rcu_read_lock(); 602 may = smk_access_entry(skp->smk_known, dsp, &skp->smk_rules); 603 rcu_read_unlock(); 604 605 /* 606 * If the access rule allows transmutation and 607 * the directory requests transmutation then 608 * by all means transmute. 609 * Mark the inode as changed. 610 */ 611 if (may > 0 && ((may & MAY_TRANSMUTE) != 0) && 612 smk_inode_transmutable(dir)) { 613 isp = dsp; 614 issp->smk_flags |= SMK_INODE_CHANGED; 615 } 616 617 *value = kstrdup(isp, GFP_NOFS); 618 if (*value == NULL) 619 return -ENOMEM; 620 } 621 622 if (len) 623 *len = strlen(isp) + 1; 624 625 return 0; 626 } 627 628 /** 629 * smack_inode_link - Smack check on link 630 * @old_dentry: the existing object 631 * @dir: unused 632 * @new_dentry: the new object 633 * 634 * Returns 0 if access is permitted, an error code otherwise 635 */ 636 static int smack_inode_link(struct dentry *old_dentry, struct inode *dir, 637 struct dentry *new_dentry) 638 { 639 char *isp; 640 struct smk_audit_info ad; 641 int rc; 642 643 smk_ad_init(&ad, __func__, LSM_AUDIT_DATA_DENTRY); 644 smk_ad_setfield_u_fs_path_dentry(&ad, old_dentry); 645 646 isp = smk_of_inode(old_dentry->d_inode); 647 rc = smk_curacc(isp, MAY_WRITE, &ad); 648 649 if (rc == 0 && new_dentry->d_inode != NULL) { 650 isp = smk_of_inode(new_dentry->d_inode); 651 smk_ad_setfield_u_fs_path_dentry(&ad, new_dentry); 652 rc = smk_curacc(isp, MAY_WRITE, &ad); 653 } 654 655 return rc; 656 } 657 658 /** 659 * smack_inode_unlink - Smack check on inode deletion 660 * @dir: containing directory object 661 * @dentry: file to unlink 662 * 663 * Returns 0 if current can write the containing directory 664 * and the object, error code otherwise 665 */ 666 static int smack_inode_unlink(struct inode *dir, struct dentry *dentry) 667 { 668 struct inode *ip = dentry->d_inode; 669 struct smk_audit_info ad; 670 int rc; 671 672 smk_ad_init(&ad, __func__, LSM_AUDIT_DATA_DENTRY); 673 smk_ad_setfield_u_fs_path_dentry(&ad, dentry); 674 675 /* 676 * You need write access to the thing you're unlinking 677 */ 678 rc = smk_curacc(smk_of_inode(ip), MAY_WRITE, &ad); 679 if (rc == 0) { 680 /* 681 * You also need write access to the containing directory 682 */ 683 smk_ad_init(&ad, __func__, LSM_AUDIT_DATA_INODE); 684 smk_ad_setfield_u_fs_inode(&ad, dir); 685 rc = smk_curacc(smk_of_inode(dir), MAY_WRITE, &ad); 686 } 687 return rc; 688 } 689 690 /** 691 * smack_inode_rmdir - Smack check on directory deletion 692 * @dir: containing directory object 693 * @dentry: directory to unlink 694 * 695 * Returns 0 if current can write the containing directory 696 * and the directory, error code otherwise 697 */ 698 static int smack_inode_rmdir(struct inode *dir, struct dentry *dentry) 699 { 700 struct smk_audit_info ad; 701 int rc; 702 703 smk_ad_init(&ad, __func__, LSM_AUDIT_DATA_DENTRY); 704 smk_ad_setfield_u_fs_path_dentry(&ad, dentry); 705 706 /* 707 * You need write access to the thing you're removing 708 */ 709 rc = smk_curacc(smk_of_inode(dentry->d_inode), MAY_WRITE, &ad); 710 if (rc == 0) { 711 /* 712 * You also need write access to the containing directory 713 */ 714 smk_ad_init(&ad, __func__, LSM_AUDIT_DATA_INODE); 715 smk_ad_setfield_u_fs_inode(&ad, dir); 716 rc = smk_curacc(smk_of_inode(dir), MAY_WRITE, &ad); 717 } 718 719 return rc; 720 } 721 722 /** 723 * smack_inode_rename - Smack check on rename 724 * @old_inode: the old directory 725 * @old_dentry: unused 726 * @new_inode: the new directory 727 * @new_dentry: unused 728 * 729 * Read and write access is required on both the old and 730 * new directories. 731 * 732 * Returns 0 if access is permitted, an error code otherwise 733 */ 734 static int smack_inode_rename(struct inode *old_inode, 735 struct dentry *old_dentry, 736 struct inode *new_inode, 737 struct dentry *new_dentry) 738 { 739 int rc; 740 char *isp; 741 struct smk_audit_info ad; 742 743 smk_ad_init(&ad, __func__, LSM_AUDIT_DATA_DENTRY); 744 smk_ad_setfield_u_fs_path_dentry(&ad, old_dentry); 745 746 isp = smk_of_inode(old_dentry->d_inode); 747 rc = smk_curacc(isp, MAY_READWRITE, &ad); 748 749 if (rc == 0 && new_dentry->d_inode != NULL) { 750 isp = smk_of_inode(new_dentry->d_inode); 751 smk_ad_setfield_u_fs_path_dentry(&ad, new_dentry); 752 rc = smk_curacc(isp, MAY_READWRITE, &ad); 753 } 754 return rc; 755 } 756 757 /** 758 * smack_inode_permission - Smack version of permission() 759 * @inode: the inode in question 760 * @mask: the access requested 761 * 762 * This is the important Smack hook. 763 * 764 * Returns 0 if access is permitted, -EACCES otherwise 765 */ 766 static int smack_inode_permission(struct inode *inode, int mask) 767 { 768 struct smk_audit_info ad; 769 int no_block = mask & MAY_NOT_BLOCK; 770 771 mask &= (MAY_READ|MAY_WRITE|MAY_EXEC|MAY_APPEND); 772 /* 773 * No permission to check. Existence test. Yup, it's there. 774 */ 775 if (mask == 0) 776 return 0; 777 778 /* May be droppable after audit */ 779 if (no_block) 780 return -ECHILD; 781 smk_ad_init(&ad, __func__, LSM_AUDIT_DATA_INODE); 782 smk_ad_setfield_u_fs_inode(&ad, inode); 783 return smk_curacc(smk_of_inode(inode), mask, &ad); 784 } 785 786 /** 787 * smack_inode_setattr - Smack check for setting attributes 788 * @dentry: the object 789 * @iattr: for the force flag 790 * 791 * Returns 0 if access is permitted, an error code otherwise 792 */ 793 static int smack_inode_setattr(struct dentry *dentry, struct iattr *iattr) 794 { 795 struct smk_audit_info ad; 796 /* 797 * Need to allow for clearing the setuid bit. 798 */ 799 if (iattr->ia_valid & ATTR_FORCE) 800 return 0; 801 smk_ad_init(&ad, __func__, LSM_AUDIT_DATA_DENTRY); 802 smk_ad_setfield_u_fs_path_dentry(&ad, dentry); 803 804 return smk_curacc(smk_of_inode(dentry->d_inode), MAY_WRITE, &ad); 805 } 806 807 /** 808 * smack_inode_getattr - Smack check for getting attributes 809 * @mnt: unused 810 * @dentry: the object 811 * 812 * Returns 0 if access is permitted, an error code otherwise 813 */ 814 static int smack_inode_getattr(struct vfsmount *mnt, struct dentry *dentry) 815 { 816 struct smk_audit_info ad; 817 struct path path; 818 819 path.dentry = dentry; 820 path.mnt = mnt; 821 822 smk_ad_init(&ad, __func__, LSM_AUDIT_DATA_PATH); 823 smk_ad_setfield_u_fs_path(&ad, path); 824 return smk_curacc(smk_of_inode(dentry->d_inode), MAY_READ, &ad); 825 } 826 827 /** 828 * smack_inode_setxattr - Smack check for setting xattrs 829 * @dentry: the object 830 * @name: name of the attribute 831 * @value: unused 832 * @size: unused 833 * @flags: unused 834 * 835 * This protects the Smack attribute explicitly. 836 * 837 * Returns 0 if access is permitted, an error code otherwise 838 */ 839 static int smack_inode_setxattr(struct dentry *dentry, const char *name, 840 const void *value, size_t size, int flags) 841 { 842 struct smk_audit_info ad; 843 int rc = 0; 844 845 if (strcmp(name, XATTR_NAME_SMACK) == 0 || 846 strcmp(name, XATTR_NAME_SMACKIPIN) == 0 || 847 strcmp(name, XATTR_NAME_SMACKIPOUT) == 0 || 848 strcmp(name, XATTR_NAME_SMACKEXEC) == 0 || 849 strcmp(name, XATTR_NAME_SMACKMMAP) == 0) { 850 if (!smack_privileged(CAP_MAC_ADMIN)) 851 rc = -EPERM; 852 /* 853 * check label validity here so import wont fail on 854 * post_setxattr 855 */ 856 if (size == 0 || size >= SMK_LONGLABEL || 857 smk_import(value, size) == NULL) 858 rc = -EINVAL; 859 } else if (strcmp(name, XATTR_NAME_SMACKTRANSMUTE) == 0) { 860 if (!smack_privileged(CAP_MAC_ADMIN)) 861 rc = -EPERM; 862 if (size != TRANS_TRUE_SIZE || 863 strncmp(value, TRANS_TRUE, TRANS_TRUE_SIZE) != 0) 864 rc = -EINVAL; 865 } else 866 rc = cap_inode_setxattr(dentry, name, value, size, flags); 867 868 smk_ad_init(&ad, __func__, LSM_AUDIT_DATA_DENTRY); 869 smk_ad_setfield_u_fs_path_dentry(&ad, dentry); 870 871 if (rc == 0) 872 rc = smk_curacc(smk_of_inode(dentry->d_inode), MAY_WRITE, &ad); 873 874 return rc; 875 } 876 877 /** 878 * smack_inode_post_setxattr - Apply the Smack update approved above 879 * @dentry: object 880 * @name: attribute name 881 * @value: attribute value 882 * @size: attribute size 883 * @flags: unused 884 * 885 * Set the pointer in the inode blob to the entry found 886 * in the master label list. 887 */ 888 static void smack_inode_post_setxattr(struct dentry *dentry, const char *name, 889 const void *value, size_t size, int flags) 890 { 891 struct smack_known *skp; 892 struct inode_smack *isp = dentry->d_inode->i_security; 893 894 if (strcmp(name, XATTR_NAME_SMACKTRANSMUTE) == 0) { 895 isp->smk_flags |= SMK_INODE_TRANSMUTE; 896 return; 897 } 898 899 skp = smk_import_entry(value, size); 900 if (strcmp(name, XATTR_NAME_SMACK) == 0) { 901 if (skp != NULL) 902 isp->smk_inode = skp->smk_known; 903 else 904 isp->smk_inode = smack_known_invalid.smk_known; 905 } else if (strcmp(name, XATTR_NAME_SMACKEXEC) == 0) { 906 if (skp != NULL) 907 isp->smk_task = skp; 908 else 909 isp->smk_task = &smack_known_invalid; 910 } else if (strcmp(name, XATTR_NAME_SMACKMMAP) == 0) { 911 if (skp != NULL) 912 isp->smk_mmap = skp; 913 else 914 isp->smk_mmap = &smack_known_invalid; 915 } 916 917 return; 918 } 919 920 /** 921 * smack_inode_getxattr - Smack check on getxattr 922 * @dentry: the object 923 * @name: unused 924 * 925 * Returns 0 if access is permitted, an error code otherwise 926 */ 927 static int smack_inode_getxattr(struct dentry *dentry, const char *name) 928 { 929 struct smk_audit_info ad; 930 931 smk_ad_init(&ad, __func__, LSM_AUDIT_DATA_DENTRY); 932 smk_ad_setfield_u_fs_path_dentry(&ad, dentry); 933 934 return smk_curacc(smk_of_inode(dentry->d_inode), MAY_READ, &ad); 935 } 936 937 /** 938 * smack_inode_removexattr - Smack check on removexattr 939 * @dentry: the object 940 * @name: name of the attribute 941 * 942 * Removing the Smack attribute requires CAP_MAC_ADMIN 943 * 944 * Returns 0 if access is permitted, an error code otherwise 945 */ 946 static int smack_inode_removexattr(struct dentry *dentry, const char *name) 947 { 948 struct inode_smack *isp; 949 struct smk_audit_info ad; 950 int rc = 0; 951 952 if (strcmp(name, XATTR_NAME_SMACK) == 0 || 953 strcmp(name, XATTR_NAME_SMACKIPIN) == 0 || 954 strcmp(name, XATTR_NAME_SMACKIPOUT) == 0 || 955 strcmp(name, XATTR_NAME_SMACKEXEC) == 0 || 956 strcmp(name, XATTR_NAME_SMACKTRANSMUTE) == 0 || 957 strcmp(name, XATTR_NAME_SMACKMMAP)) { 958 if (!smack_privileged(CAP_MAC_ADMIN)) 959 rc = -EPERM; 960 } else 961 rc = cap_inode_removexattr(dentry, name); 962 963 smk_ad_init(&ad, __func__, LSM_AUDIT_DATA_DENTRY); 964 smk_ad_setfield_u_fs_path_dentry(&ad, dentry); 965 if (rc == 0) 966 rc = smk_curacc(smk_of_inode(dentry->d_inode), MAY_WRITE, &ad); 967 968 if (rc == 0) { 969 isp = dentry->d_inode->i_security; 970 isp->smk_task = NULL; 971 isp->smk_mmap = NULL; 972 } 973 974 return rc; 975 } 976 977 /** 978 * smack_inode_getsecurity - get smack xattrs 979 * @inode: the object 980 * @name: attribute name 981 * @buffer: where to put the result 982 * @alloc: unused 983 * 984 * Returns the size of the attribute or an error code 985 */ 986 static int smack_inode_getsecurity(const struct inode *inode, 987 const char *name, void **buffer, 988 bool alloc) 989 { 990 struct socket_smack *ssp; 991 struct socket *sock; 992 struct super_block *sbp; 993 struct inode *ip = (struct inode *)inode; 994 char *isp; 995 int ilen; 996 int rc = 0; 997 998 if (strcmp(name, XATTR_SMACK_SUFFIX) == 0) { 999 isp = smk_of_inode(inode); 1000 ilen = strlen(isp) + 1; 1001 *buffer = isp; 1002 return ilen; 1003 } 1004 1005 /* 1006 * The rest of the Smack xattrs are only on sockets. 1007 */ 1008 sbp = ip->i_sb; 1009 if (sbp->s_magic != SOCKFS_MAGIC) 1010 return -EOPNOTSUPP; 1011 1012 sock = SOCKET_I(ip); 1013 if (sock == NULL || sock->sk == NULL) 1014 return -EOPNOTSUPP; 1015 1016 ssp = sock->sk->sk_security; 1017 1018 if (strcmp(name, XATTR_SMACK_IPIN) == 0) 1019 isp = ssp->smk_in; 1020 else if (strcmp(name, XATTR_SMACK_IPOUT) == 0) 1021 isp = ssp->smk_out->smk_known; 1022 else 1023 return -EOPNOTSUPP; 1024 1025 ilen = strlen(isp) + 1; 1026 if (rc == 0) { 1027 *buffer = isp; 1028 rc = ilen; 1029 } 1030 1031 return rc; 1032 } 1033 1034 1035 /** 1036 * smack_inode_listsecurity - list the Smack attributes 1037 * @inode: the object 1038 * @buffer: where they go 1039 * @buffer_size: size of buffer 1040 * 1041 * Returns 0 on success, -EINVAL otherwise 1042 */ 1043 static int smack_inode_listsecurity(struct inode *inode, char *buffer, 1044 size_t buffer_size) 1045 { 1046 int len = strlen(XATTR_NAME_SMACK); 1047 1048 if (buffer != NULL && len <= buffer_size) { 1049 memcpy(buffer, XATTR_NAME_SMACK, len); 1050 return len; 1051 } 1052 return -EINVAL; 1053 } 1054 1055 /** 1056 * smack_inode_getsecid - Extract inode's security id 1057 * @inode: inode to extract the info from 1058 * @secid: where result will be saved 1059 */ 1060 static void smack_inode_getsecid(const struct inode *inode, u32 *secid) 1061 { 1062 struct inode_smack *isp = inode->i_security; 1063 1064 *secid = smack_to_secid(isp->smk_inode); 1065 } 1066 1067 /* 1068 * File Hooks 1069 */ 1070 1071 /** 1072 * smack_file_permission - Smack check on file operations 1073 * @file: unused 1074 * @mask: unused 1075 * 1076 * Returns 0 1077 * 1078 * Should access checks be done on each read or write? 1079 * UNICOS and SELinux say yes. 1080 * Trusted Solaris, Trusted Irix, and just about everyone else says no. 1081 * 1082 * I'll say no for now. Smack does not do the frequent 1083 * label changing that SELinux does. 1084 */ 1085 static int smack_file_permission(struct file *file, int mask) 1086 { 1087 return 0; 1088 } 1089 1090 /** 1091 * smack_file_alloc_security - assign a file security blob 1092 * @file: the object 1093 * 1094 * The security blob for a file is a pointer to the master 1095 * label list, so no allocation is done. 1096 * 1097 * Returns 0 1098 */ 1099 static int smack_file_alloc_security(struct file *file) 1100 { 1101 struct smack_known *skp = smk_of_current(); 1102 1103 file->f_security = skp->smk_known; 1104 return 0; 1105 } 1106 1107 /** 1108 * smack_file_free_security - clear a file security blob 1109 * @file: the object 1110 * 1111 * The security blob for a file is a pointer to the master 1112 * label list, so no memory is freed. 1113 */ 1114 static void smack_file_free_security(struct file *file) 1115 { 1116 file->f_security = NULL; 1117 } 1118 1119 /** 1120 * smack_file_ioctl - Smack check on ioctls 1121 * @file: the object 1122 * @cmd: what to do 1123 * @arg: unused 1124 * 1125 * Relies heavily on the correct use of the ioctl command conventions. 1126 * 1127 * Returns 0 if allowed, error code otherwise 1128 */ 1129 static int smack_file_ioctl(struct file *file, unsigned int cmd, 1130 unsigned long arg) 1131 { 1132 int rc = 0; 1133 struct smk_audit_info ad; 1134 1135 smk_ad_init(&ad, __func__, LSM_AUDIT_DATA_PATH); 1136 smk_ad_setfield_u_fs_path(&ad, file->f_path); 1137 1138 if (_IOC_DIR(cmd) & _IOC_WRITE) 1139 rc = smk_curacc(file->f_security, MAY_WRITE, &ad); 1140 1141 if (rc == 0 && (_IOC_DIR(cmd) & _IOC_READ)) 1142 rc = smk_curacc(file->f_security, MAY_READ, &ad); 1143 1144 return rc; 1145 } 1146 1147 /** 1148 * smack_file_lock - Smack check on file locking 1149 * @file: the object 1150 * @cmd: unused 1151 * 1152 * Returns 0 if current has write access, error code otherwise 1153 */ 1154 static int smack_file_lock(struct file *file, unsigned int cmd) 1155 { 1156 struct smk_audit_info ad; 1157 1158 smk_ad_init(&ad, __func__, LSM_AUDIT_DATA_PATH); 1159 smk_ad_setfield_u_fs_path(&ad, file->f_path); 1160 return smk_curacc(file->f_security, MAY_WRITE, &ad); 1161 } 1162 1163 /** 1164 * smack_file_fcntl - Smack check on fcntl 1165 * @file: the object 1166 * @cmd: what action to check 1167 * @arg: unused 1168 * 1169 * Generally these operations are harmless. 1170 * File locking operations present an obvious mechanism 1171 * for passing information, so they require write access. 1172 * 1173 * Returns 0 if current has access, error code otherwise 1174 */ 1175 static int smack_file_fcntl(struct file *file, unsigned int cmd, 1176 unsigned long arg) 1177 { 1178 struct smk_audit_info ad; 1179 int rc = 0; 1180 1181 1182 switch (cmd) { 1183 case F_GETLK: 1184 case F_SETLK: 1185 case F_SETLKW: 1186 case F_SETOWN: 1187 case F_SETSIG: 1188 smk_ad_init(&ad, __func__, LSM_AUDIT_DATA_PATH); 1189 smk_ad_setfield_u_fs_path(&ad, file->f_path); 1190 rc = smk_curacc(file->f_security, MAY_WRITE, &ad); 1191 break; 1192 default: 1193 break; 1194 } 1195 1196 return rc; 1197 } 1198 1199 /** 1200 * smack_mmap_file : 1201 * Check permissions for a mmap operation. The @file may be NULL, e.g. 1202 * if mapping anonymous memory. 1203 * @file contains the file structure for file to map (may be NULL). 1204 * @reqprot contains the protection requested by the application. 1205 * @prot contains the protection that will be applied by the kernel. 1206 * @flags contains the operational flags. 1207 * Return 0 if permission is granted. 1208 */ 1209 static int smack_mmap_file(struct file *file, 1210 unsigned long reqprot, unsigned long prot, 1211 unsigned long flags) 1212 { 1213 struct smack_known *skp; 1214 struct smack_known *mkp; 1215 struct smack_rule *srp; 1216 struct task_smack *tsp; 1217 char *osmack; 1218 struct inode_smack *isp; 1219 int may; 1220 int mmay; 1221 int tmay; 1222 int rc; 1223 1224 if (file == NULL) 1225 return 0; 1226 1227 isp = file_inode(file)->i_security; 1228 if (isp->smk_mmap == NULL) 1229 return 0; 1230 mkp = isp->smk_mmap; 1231 1232 tsp = current_security(); 1233 skp = smk_of_current(); 1234 rc = 0; 1235 1236 rcu_read_lock(); 1237 /* 1238 * For each Smack rule associated with the subject 1239 * label verify that the SMACK64MMAP also has access 1240 * to that rule's object label. 1241 */ 1242 list_for_each_entry_rcu(srp, &skp->smk_rules, list) { 1243 osmack = srp->smk_object; 1244 /* 1245 * Matching labels always allows access. 1246 */ 1247 if (mkp->smk_known == osmack) 1248 continue; 1249 /* 1250 * If there is a matching local rule take 1251 * that into account as well. 1252 */ 1253 may = smk_access_entry(srp->smk_subject->smk_known, osmack, 1254 &tsp->smk_rules); 1255 if (may == -ENOENT) 1256 may = srp->smk_access; 1257 else 1258 may &= srp->smk_access; 1259 /* 1260 * If may is zero the SMACK64MMAP subject can't 1261 * possibly have less access. 1262 */ 1263 if (may == 0) 1264 continue; 1265 1266 /* 1267 * Fetch the global list entry. 1268 * If there isn't one a SMACK64MMAP subject 1269 * can't have as much access as current. 1270 */ 1271 mmay = smk_access_entry(mkp->smk_known, osmack, 1272 &mkp->smk_rules); 1273 if (mmay == -ENOENT) { 1274 rc = -EACCES; 1275 break; 1276 } 1277 /* 1278 * If there is a local entry it modifies the 1279 * potential access, too. 1280 */ 1281 tmay = smk_access_entry(mkp->smk_known, osmack, 1282 &tsp->smk_rules); 1283 if (tmay != -ENOENT) 1284 mmay &= tmay; 1285 1286 /* 1287 * If there is any access available to current that is 1288 * not available to a SMACK64MMAP subject 1289 * deny access. 1290 */ 1291 if ((may | mmay) != mmay) { 1292 rc = -EACCES; 1293 break; 1294 } 1295 } 1296 1297 rcu_read_unlock(); 1298 1299 return rc; 1300 } 1301 1302 /** 1303 * smack_file_set_fowner - set the file security blob value 1304 * @file: object in question 1305 * 1306 * Returns 0 1307 * Further research may be required on this one. 1308 */ 1309 static int smack_file_set_fowner(struct file *file) 1310 { 1311 struct smack_known *skp = smk_of_current(); 1312 1313 file->f_security = skp->smk_known; 1314 return 0; 1315 } 1316 1317 /** 1318 * smack_file_send_sigiotask - Smack on sigio 1319 * @tsk: The target task 1320 * @fown: the object the signal come from 1321 * @signum: unused 1322 * 1323 * Allow a privileged task to get signals even if it shouldn't 1324 * 1325 * Returns 0 if a subject with the object's smack could 1326 * write to the task, an error code otherwise. 1327 */ 1328 static int smack_file_send_sigiotask(struct task_struct *tsk, 1329 struct fown_struct *fown, int signum) 1330 { 1331 struct smack_known *skp; 1332 struct smack_known *tkp = smk_of_task(tsk->cred->security); 1333 struct file *file; 1334 int rc; 1335 struct smk_audit_info ad; 1336 1337 /* 1338 * struct fown_struct is never outside the context of a struct file 1339 */ 1340 file = container_of(fown, struct file, f_owner); 1341 1342 /* we don't log here as rc can be overriden */ 1343 skp = smk_find_entry(file->f_security); 1344 rc = smk_access(skp, tkp->smk_known, MAY_WRITE, NULL); 1345 if (rc != 0 && has_capability(tsk, CAP_MAC_OVERRIDE)) 1346 rc = 0; 1347 1348 smk_ad_init(&ad, __func__, LSM_AUDIT_DATA_TASK); 1349 smk_ad_setfield_u_tsk(&ad, tsk); 1350 smack_log(file->f_security, tkp->smk_known, MAY_WRITE, rc, &ad); 1351 return rc; 1352 } 1353 1354 /** 1355 * smack_file_receive - Smack file receive check 1356 * @file: the object 1357 * 1358 * Returns 0 if current has access, error code otherwise 1359 */ 1360 static int smack_file_receive(struct file *file) 1361 { 1362 int may = 0; 1363 struct smk_audit_info ad; 1364 1365 smk_ad_init(&ad, __func__, LSM_AUDIT_DATA_TASK); 1366 smk_ad_setfield_u_fs_path(&ad, file->f_path); 1367 /* 1368 * This code relies on bitmasks. 1369 */ 1370 if (file->f_mode & FMODE_READ) 1371 may = MAY_READ; 1372 if (file->f_mode & FMODE_WRITE) 1373 may |= MAY_WRITE; 1374 1375 return smk_curacc(file->f_security, may, &ad); 1376 } 1377 1378 /** 1379 * smack_file_open - Smack dentry open processing 1380 * @file: the object 1381 * @cred: unused 1382 * 1383 * Set the security blob in the file structure. 1384 * 1385 * Returns 0 1386 */ 1387 static int smack_file_open(struct file *file, const struct cred *cred) 1388 { 1389 struct inode_smack *isp = file_inode(file)->i_security; 1390 1391 file->f_security = isp->smk_inode; 1392 1393 return 0; 1394 } 1395 1396 /* 1397 * Task hooks 1398 */ 1399 1400 /** 1401 * smack_cred_alloc_blank - "allocate" blank task-level security credentials 1402 * @new: the new credentials 1403 * @gfp: the atomicity of any memory allocations 1404 * 1405 * Prepare a blank set of credentials for modification. This must allocate all 1406 * the memory the LSM module might require such that cred_transfer() can 1407 * complete without error. 1408 */ 1409 static int smack_cred_alloc_blank(struct cred *cred, gfp_t gfp) 1410 { 1411 struct task_smack *tsp; 1412 1413 tsp = new_task_smack(NULL, NULL, gfp); 1414 if (tsp == NULL) 1415 return -ENOMEM; 1416 1417 cred->security = tsp; 1418 1419 return 0; 1420 } 1421 1422 1423 /** 1424 * smack_cred_free - "free" task-level security credentials 1425 * @cred: the credentials in question 1426 * 1427 */ 1428 static void smack_cred_free(struct cred *cred) 1429 { 1430 struct task_smack *tsp = cred->security; 1431 struct smack_rule *rp; 1432 struct list_head *l; 1433 struct list_head *n; 1434 1435 if (tsp == NULL) 1436 return; 1437 cred->security = NULL; 1438 1439 list_for_each_safe(l, n, &tsp->smk_rules) { 1440 rp = list_entry(l, struct smack_rule, list); 1441 list_del(&rp->list); 1442 kfree(rp); 1443 } 1444 kfree(tsp); 1445 } 1446 1447 /** 1448 * smack_cred_prepare - prepare new set of credentials for modification 1449 * @new: the new credentials 1450 * @old: the original credentials 1451 * @gfp: the atomicity of any memory allocations 1452 * 1453 * Prepare a new set of credentials for modification. 1454 */ 1455 static int smack_cred_prepare(struct cred *new, const struct cred *old, 1456 gfp_t gfp) 1457 { 1458 struct task_smack *old_tsp = old->security; 1459 struct task_smack *new_tsp; 1460 int rc; 1461 1462 new_tsp = new_task_smack(old_tsp->smk_task, old_tsp->smk_task, gfp); 1463 if (new_tsp == NULL) 1464 return -ENOMEM; 1465 1466 rc = smk_copy_rules(&new_tsp->smk_rules, &old_tsp->smk_rules, gfp); 1467 if (rc != 0) 1468 return rc; 1469 1470 new->security = new_tsp; 1471 return 0; 1472 } 1473 1474 /** 1475 * smack_cred_transfer - Transfer the old credentials to the new credentials 1476 * @new: the new credentials 1477 * @old: the original credentials 1478 * 1479 * Fill in a set of blank credentials from another set of credentials. 1480 */ 1481 static void smack_cred_transfer(struct cred *new, const struct cred *old) 1482 { 1483 struct task_smack *old_tsp = old->security; 1484 struct task_smack *new_tsp = new->security; 1485 1486 new_tsp->smk_task = old_tsp->smk_task; 1487 new_tsp->smk_forked = old_tsp->smk_task; 1488 mutex_init(&new_tsp->smk_rules_lock); 1489 INIT_LIST_HEAD(&new_tsp->smk_rules); 1490 1491 1492 /* cbs copy rule list */ 1493 } 1494 1495 /** 1496 * smack_kernel_act_as - Set the subjective context in a set of credentials 1497 * @new: points to the set of credentials to be modified. 1498 * @secid: specifies the security ID to be set 1499 * 1500 * Set the security data for a kernel service. 1501 */ 1502 static int smack_kernel_act_as(struct cred *new, u32 secid) 1503 { 1504 struct task_smack *new_tsp = new->security; 1505 struct smack_known *skp = smack_from_secid(secid); 1506 1507 if (skp == NULL) 1508 return -EINVAL; 1509 1510 new_tsp->smk_task = skp; 1511 return 0; 1512 } 1513 1514 /** 1515 * smack_kernel_create_files_as - Set the file creation label in a set of creds 1516 * @new: points to the set of credentials to be modified 1517 * @inode: points to the inode to use as a reference 1518 * 1519 * Set the file creation context in a set of credentials to the same 1520 * as the objective context of the specified inode 1521 */ 1522 static int smack_kernel_create_files_as(struct cred *new, 1523 struct inode *inode) 1524 { 1525 struct inode_smack *isp = inode->i_security; 1526 struct task_smack *tsp = new->security; 1527 1528 tsp->smk_forked = smk_find_entry(isp->smk_inode); 1529 tsp->smk_task = tsp->smk_forked; 1530 return 0; 1531 } 1532 1533 /** 1534 * smk_curacc_on_task - helper to log task related access 1535 * @p: the task object 1536 * @access: the access requested 1537 * @caller: name of the calling function for audit 1538 * 1539 * Return 0 if access is permitted 1540 */ 1541 static int smk_curacc_on_task(struct task_struct *p, int access, 1542 const char *caller) 1543 { 1544 struct smk_audit_info ad; 1545 struct smack_known *skp = smk_of_task(task_security(p)); 1546 1547 smk_ad_init(&ad, caller, LSM_AUDIT_DATA_TASK); 1548 smk_ad_setfield_u_tsk(&ad, p); 1549 return smk_curacc(skp->smk_known, access, &ad); 1550 } 1551 1552 /** 1553 * smack_task_setpgid - Smack check on setting pgid 1554 * @p: the task object 1555 * @pgid: unused 1556 * 1557 * Return 0 if write access is permitted 1558 */ 1559 static int smack_task_setpgid(struct task_struct *p, pid_t pgid) 1560 { 1561 return smk_curacc_on_task(p, MAY_WRITE, __func__); 1562 } 1563 1564 /** 1565 * smack_task_getpgid - Smack access check for getpgid 1566 * @p: the object task 1567 * 1568 * Returns 0 if current can read the object task, error code otherwise 1569 */ 1570 static int smack_task_getpgid(struct task_struct *p) 1571 { 1572 return smk_curacc_on_task(p, MAY_READ, __func__); 1573 } 1574 1575 /** 1576 * smack_task_getsid - Smack access check for getsid 1577 * @p: the object task 1578 * 1579 * Returns 0 if current can read the object task, error code otherwise 1580 */ 1581 static int smack_task_getsid(struct task_struct *p) 1582 { 1583 return smk_curacc_on_task(p, MAY_READ, __func__); 1584 } 1585 1586 /** 1587 * smack_task_getsecid - get the secid of the task 1588 * @p: the object task 1589 * @secid: where to put the result 1590 * 1591 * Sets the secid to contain a u32 version of the smack label. 1592 */ 1593 static void smack_task_getsecid(struct task_struct *p, u32 *secid) 1594 { 1595 struct smack_known *skp = smk_of_task(task_security(p)); 1596 1597 *secid = skp->smk_secid; 1598 } 1599 1600 /** 1601 * smack_task_setnice - Smack check on setting nice 1602 * @p: the task object 1603 * @nice: unused 1604 * 1605 * Return 0 if write access is permitted 1606 */ 1607 static int smack_task_setnice(struct task_struct *p, int nice) 1608 { 1609 int rc; 1610 1611 rc = cap_task_setnice(p, nice); 1612 if (rc == 0) 1613 rc = smk_curacc_on_task(p, MAY_WRITE, __func__); 1614 return rc; 1615 } 1616 1617 /** 1618 * smack_task_setioprio - Smack check on setting ioprio 1619 * @p: the task object 1620 * @ioprio: unused 1621 * 1622 * Return 0 if write access is permitted 1623 */ 1624 static int smack_task_setioprio(struct task_struct *p, int ioprio) 1625 { 1626 int rc; 1627 1628 rc = cap_task_setioprio(p, ioprio); 1629 if (rc == 0) 1630 rc = smk_curacc_on_task(p, MAY_WRITE, __func__); 1631 return rc; 1632 } 1633 1634 /** 1635 * smack_task_getioprio - Smack check on reading ioprio 1636 * @p: the task object 1637 * 1638 * Return 0 if read access is permitted 1639 */ 1640 static int smack_task_getioprio(struct task_struct *p) 1641 { 1642 return smk_curacc_on_task(p, MAY_READ, __func__); 1643 } 1644 1645 /** 1646 * smack_task_setscheduler - Smack check on setting scheduler 1647 * @p: the task object 1648 * @policy: unused 1649 * @lp: unused 1650 * 1651 * Return 0 if read access is permitted 1652 */ 1653 static int smack_task_setscheduler(struct task_struct *p) 1654 { 1655 int rc; 1656 1657 rc = cap_task_setscheduler(p); 1658 if (rc == 0) 1659 rc = smk_curacc_on_task(p, MAY_WRITE, __func__); 1660 return rc; 1661 } 1662 1663 /** 1664 * smack_task_getscheduler - Smack check on reading scheduler 1665 * @p: the task object 1666 * 1667 * Return 0 if read access is permitted 1668 */ 1669 static int smack_task_getscheduler(struct task_struct *p) 1670 { 1671 return smk_curacc_on_task(p, MAY_READ, __func__); 1672 } 1673 1674 /** 1675 * smack_task_movememory - Smack check on moving memory 1676 * @p: the task object 1677 * 1678 * Return 0 if write access is permitted 1679 */ 1680 static int smack_task_movememory(struct task_struct *p) 1681 { 1682 return smk_curacc_on_task(p, MAY_WRITE, __func__); 1683 } 1684 1685 /** 1686 * smack_task_kill - Smack check on signal delivery 1687 * @p: the task object 1688 * @info: unused 1689 * @sig: unused 1690 * @secid: identifies the smack to use in lieu of current's 1691 * 1692 * Return 0 if write access is permitted 1693 * 1694 * The secid behavior is an artifact of an SELinux hack 1695 * in the USB code. Someday it may go away. 1696 */ 1697 static int smack_task_kill(struct task_struct *p, struct siginfo *info, 1698 int sig, u32 secid) 1699 { 1700 struct smk_audit_info ad; 1701 struct smack_known *skp; 1702 struct smack_known *tkp = smk_of_task(task_security(p)); 1703 1704 smk_ad_init(&ad, __func__, LSM_AUDIT_DATA_TASK); 1705 smk_ad_setfield_u_tsk(&ad, p); 1706 /* 1707 * Sending a signal requires that the sender 1708 * can write the receiver. 1709 */ 1710 if (secid == 0) 1711 return smk_curacc(tkp->smk_known, MAY_WRITE, &ad); 1712 /* 1713 * If the secid isn't 0 we're dealing with some USB IO 1714 * specific behavior. This is not clean. For one thing 1715 * we can't take privilege into account. 1716 */ 1717 skp = smack_from_secid(secid); 1718 return smk_access(skp, tkp->smk_known, MAY_WRITE, &ad); 1719 } 1720 1721 /** 1722 * smack_task_wait - Smack access check for waiting 1723 * @p: task to wait for 1724 * 1725 * Returns 0 1726 */ 1727 static int smack_task_wait(struct task_struct *p) 1728 { 1729 /* 1730 * Allow the operation to succeed. 1731 * Zombies are bad. 1732 * In userless environments (e.g. phones) programs 1733 * get marked with SMACK64EXEC and even if the parent 1734 * and child shouldn't be talking the parent still 1735 * may expect to know when the child exits. 1736 */ 1737 return 0; 1738 } 1739 1740 /** 1741 * smack_task_to_inode - copy task smack into the inode blob 1742 * @p: task to copy from 1743 * @inode: inode to copy to 1744 * 1745 * Sets the smack pointer in the inode security blob 1746 */ 1747 static void smack_task_to_inode(struct task_struct *p, struct inode *inode) 1748 { 1749 struct inode_smack *isp = inode->i_security; 1750 struct smack_known *skp = smk_of_task(task_security(p)); 1751 1752 isp->smk_inode = skp->smk_known; 1753 } 1754 1755 /* 1756 * Socket hooks. 1757 */ 1758 1759 /** 1760 * smack_sk_alloc_security - Allocate a socket blob 1761 * @sk: the socket 1762 * @family: unused 1763 * @gfp_flags: memory allocation flags 1764 * 1765 * Assign Smack pointers to current 1766 * 1767 * Returns 0 on success, -ENOMEM is there's no memory 1768 */ 1769 static int smack_sk_alloc_security(struct sock *sk, int family, gfp_t gfp_flags) 1770 { 1771 struct smack_known *skp = smk_of_current(); 1772 struct socket_smack *ssp; 1773 1774 ssp = kzalloc(sizeof(struct socket_smack), gfp_flags); 1775 if (ssp == NULL) 1776 return -ENOMEM; 1777 1778 ssp->smk_in = skp->smk_known; 1779 ssp->smk_out = skp; 1780 ssp->smk_packet = NULL; 1781 1782 sk->sk_security = ssp; 1783 1784 return 0; 1785 } 1786 1787 /** 1788 * smack_sk_free_security - Free a socket blob 1789 * @sk: the socket 1790 * 1791 * Clears the blob pointer 1792 */ 1793 static void smack_sk_free_security(struct sock *sk) 1794 { 1795 kfree(sk->sk_security); 1796 } 1797 1798 /** 1799 * smack_host_label - check host based restrictions 1800 * @sip: the object end 1801 * 1802 * looks for host based access restrictions 1803 * 1804 * This version will only be appropriate for really small sets of single label 1805 * hosts. The caller is responsible for ensuring that the RCU read lock is 1806 * taken before calling this function. 1807 * 1808 * Returns the label of the far end or NULL if it's not special. 1809 */ 1810 static char *smack_host_label(struct sockaddr_in *sip) 1811 { 1812 struct smk_netlbladdr *snp; 1813 struct in_addr *siap = &sip->sin_addr; 1814 1815 if (siap->s_addr == 0) 1816 return NULL; 1817 1818 list_for_each_entry_rcu(snp, &smk_netlbladdr_list, list) 1819 /* 1820 * we break after finding the first match because 1821 * the list is sorted from longest to shortest mask 1822 * so we have found the most specific match 1823 */ 1824 if ((&snp->smk_host.sin_addr)->s_addr == 1825 (siap->s_addr & (&snp->smk_mask)->s_addr)) { 1826 /* we have found the special CIPSO option */ 1827 if (snp->smk_label == smack_cipso_option) 1828 return NULL; 1829 return snp->smk_label; 1830 } 1831 1832 return NULL; 1833 } 1834 1835 /** 1836 * smack_netlabel - Set the secattr on a socket 1837 * @sk: the socket 1838 * @labeled: socket label scheme 1839 * 1840 * Convert the outbound smack value (smk_out) to a 1841 * secattr and attach it to the socket. 1842 * 1843 * Returns 0 on success or an error code 1844 */ 1845 static int smack_netlabel(struct sock *sk, int labeled) 1846 { 1847 struct smack_known *skp; 1848 struct socket_smack *ssp = sk->sk_security; 1849 int rc = 0; 1850 1851 /* 1852 * Usually the netlabel code will handle changing the 1853 * packet labeling based on the label. 1854 * The case of a single label host is different, because 1855 * a single label host should never get a labeled packet 1856 * even though the label is usually associated with a packet 1857 * label. 1858 */ 1859 local_bh_disable(); 1860 bh_lock_sock_nested(sk); 1861 1862 if (ssp->smk_out == smack_net_ambient || 1863 labeled == SMACK_UNLABELED_SOCKET) 1864 netlbl_sock_delattr(sk); 1865 else { 1866 skp = ssp->smk_out; 1867 rc = netlbl_sock_setattr(sk, sk->sk_family, &skp->smk_netlabel); 1868 } 1869 1870 bh_unlock_sock(sk); 1871 local_bh_enable(); 1872 1873 return rc; 1874 } 1875 1876 /** 1877 * smack_netlbel_send - Set the secattr on a socket and perform access checks 1878 * @sk: the socket 1879 * @sap: the destination address 1880 * 1881 * Set the correct secattr for the given socket based on the destination 1882 * address and perform any outbound access checks needed. 1883 * 1884 * Returns 0 on success or an error code. 1885 * 1886 */ 1887 static int smack_netlabel_send(struct sock *sk, struct sockaddr_in *sap) 1888 { 1889 struct smack_known *skp; 1890 int rc; 1891 int sk_lbl; 1892 char *hostsp; 1893 struct socket_smack *ssp = sk->sk_security; 1894 struct smk_audit_info ad; 1895 1896 rcu_read_lock(); 1897 hostsp = smack_host_label(sap); 1898 if (hostsp != NULL) { 1899 #ifdef CONFIG_AUDIT 1900 struct lsm_network_audit net; 1901 1902 smk_ad_init_net(&ad, __func__, LSM_AUDIT_DATA_NET, &net); 1903 ad.a.u.net->family = sap->sin_family; 1904 ad.a.u.net->dport = sap->sin_port; 1905 ad.a.u.net->v4info.daddr = sap->sin_addr.s_addr; 1906 #endif 1907 sk_lbl = SMACK_UNLABELED_SOCKET; 1908 skp = ssp->smk_out; 1909 rc = smk_access(skp, hostsp, MAY_WRITE, &ad); 1910 } else { 1911 sk_lbl = SMACK_CIPSO_SOCKET; 1912 rc = 0; 1913 } 1914 rcu_read_unlock(); 1915 if (rc != 0) 1916 return rc; 1917 1918 return smack_netlabel(sk, sk_lbl); 1919 } 1920 1921 /** 1922 * smk_ipv6_port_label - Smack port access table management 1923 * @sock: socket 1924 * @address: address 1925 * 1926 * Create or update the port list entry 1927 */ 1928 static void smk_ipv6_port_label(struct socket *sock, struct sockaddr *address) 1929 { 1930 struct sock *sk = sock->sk; 1931 struct sockaddr_in6 *addr6; 1932 struct socket_smack *ssp = sock->sk->sk_security; 1933 struct smk_port_label *spp; 1934 unsigned short port = 0; 1935 1936 if (address == NULL) { 1937 /* 1938 * This operation is changing the Smack information 1939 * on the bound socket. Take the changes to the port 1940 * as well. 1941 */ 1942 list_for_each_entry(spp, &smk_ipv6_port_list, list) { 1943 if (sk != spp->smk_sock) 1944 continue; 1945 spp->smk_in = ssp->smk_in; 1946 spp->smk_out = ssp->smk_out; 1947 return; 1948 } 1949 /* 1950 * A NULL address is only used for updating existing 1951 * bound entries. If there isn't one, it's OK. 1952 */ 1953 return; 1954 } 1955 1956 addr6 = (struct sockaddr_in6 *)address; 1957 port = ntohs(addr6->sin6_port); 1958 /* 1959 * This is a special case that is safely ignored. 1960 */ 1961 if (port == 0) 1962 return; 1963 1964 /* 1965 * Look for an existing port list entry. 1966 * This is an indication that a port is getting reused. 1967 */ 1968 list_for_each_entry(spp, &smk_ipv6_port_list, list) { 1969 if (spp->smk_port != port) 1970 continue; 1971 spp->smk_port = port; 1972 spp->smk_sock = sk; 1973 spp->smk_in = ssp->smk_in; 1974 spp->smk_out = ssp->smk_out; 1975 return; 1976 } 1977 1978 /* 1979 * A new port entry is required. 1980 */ 1981 spp = kzalloc(sizeof(*spp), GFP_KERNEL); 1982 if (spp == NULL) 1983 return; 1984 1985 spp->smk_port = port; 1986 spp->smk_sock = sk; 1987 spp->smk_in = ssp->smk_in; 1988 spp->smk_out = ssp->smk_out; 1989 1990 list_add(&spp->list, &smk_ipv6_port_list); 1991 return; 1992 } 1993 1994 /** 1995 * smk_ipv6_port_check - check Smack port access 1996 * @sock: socket 1997 * @address: address 1998 * 1999 * Create or update the port list entry 2000 */ 2001 static int smk_ipv6_port_check(struct sock *sk, struct sockaddr *address, 2002 int act) 2003 { 2004 __be16 *bep; 2005 __be32 *be32p; 2006 struct sockaddr_in6 *addr6; 2007 struct smk_port_label *spp; 2008 struct socket_smack *ssp = sk->sk_security; 2009 struct smack_known *skp; 2010 unsigned short port = 0; 2011 char *object; 2012 struct smk_audit_info ad; 2013 #ifdef CONFIG_AUDIT 2014 struct lsm_network_audit net; 2015 #endif 2016 2017 if (act == SMK_RECEIVING) { 2018 skp = smack_net_ambient; 2019 object = ssp->smk_in; 2020 } else { 2021 skp = ssp->smk_out; 2022 object = smack_net_ambient->smk_known; 2023 } 2024 2025 /* 2026 * Get the IP address and port from the address. 2027 */ 2028 addr6 = (struct sockaddr_in6 *)address; 2029 port = ntohs(addr6->sin6_port); 2030 bep = (__be16 *)(&addr6->sin6_addr); 2031 be32p = (__be32 *)(&addr6->sin6_addr); 2032 2033 /* 2034 * It's remote, so port lookup does no good. 2035 */ 2036 if (be32p[0] || be32p[1] || be32p[2] || bep[6] || ntohs(bep[7]) != 1) 2037 goto auditout; 2038 2039 /* 2040 * It's local so the send check has to have passed. 2041 */ 2042 if (act == SMK_RECEIVING) { 2043 skp = &smack_known_web; 2044 goto auditout; 2045 } 2046 2047 list_for_each_entry(spp, &smk_ipv6_port_list, list) { 2048 if (spp->smk_port != port) 2049 continue; 2050 object = spp->smk_in; 2051 if (act == SMK_CONNECTING) 2052 ssp->smk_packet = spp->smk_out->smk_known; 2053 break; 2054 } 2055 2056 auditout: 2057 2058 #ifdef CONFIG_AUDIT 2059 smk_ad_init_net(&ad, __func__, LSM_AUDIT_DATA_NET, &net); 2060 ad.a.u.net->family = sk->sk_family; 2061 ad.a.u.net->dport = port; 2062 if (act == SMK_RECEIVING) 2063 ad.a.u.net->v6info.saddr = addr6->sin6_addr; 2064 else 2065 ad.a.u.net->v6info.daddr = addr6->sin6_addr; 2066 #endif 2067 return smk_access(skp, object, MAY_WRITE, &ad); 2068 } 2069 2070 /** 2071 * smack_inode_setsecurity - set smack xattrs 2072 * @inode: the object 2073 * @name: attribute name 2074 * @value: attribute value 2075 * @size: size of the attribute 2076 * @flags: unused 2077 * 2078 * Sets the named attribute in the appropriate blob 2079 * 2080 * Returns 0 on success, or an error code 2081 */ 2082 static int smack_inode_setsecurity(struct inode *inode, const char *name, 2083 const void *value, size_t size, int flags) 2084 { 2085 struct smack_known *skp; 2086 struct inode_smack *nsp = inode->i_security; 2087 struct socket_smack *ssp; 2088 struct socket *sock; 2089 int rc = 0; 2090 2091 if (value == NULL || size > SMK_LONGLABEL || size == 0) 2092 return -EACCES; 2093 2094 skp = smk_import_entry(value, size); 2095 if (skp == NULL) 2096 return -EINVAL; 2097 2098 if (strcmp(name, XATTR_SMACK_SUFFIX) == 0) { 2099 nsp->smk_inode = skp->smk_known; 2100 nsp->smk_flags |= SMK_INODE_INSTANT; 2101 return 0; 2102 } 2103 /* 2104 * The rest of the Smack xattrs are only on sockets. 2105 */ 2106 if (inode->i_sb->s_magic != SOCKFS_MAGIC) 2107 return -EOPNOTSUPP; 2108 2109 sock = SOCKET_I(inode); 2110 if (sock == NULL || sock->sk == NULL) 2111 return -EOPNOTSUPP; 2112 2113 ssp = sock->sk->sk_security; 2114 2115 if (strcmp(name, XATTR_SMACK_IPIN) == 0) 2116 ssp->smk_in = skp->smk_known; 2117 else if (strcmp(name, XATTR_SMACK_IPOUT) == 0) { 2118 ssp->smk_out = skp; 2119 if (sock->sk->sk_family == PF_INET) { 2120 rc = smack_netlabel(sock->sk, SMACK_CIPSO_SOCKET); 2121 if (rc != 0) 2122 printk(KERN_WARNING 2123 "Smack: \"%s\" netlbl error %d.\n", 2124 __func__, -rc); 2125 } 2126 } else 2127 return -EOPNOTSUPP; 2128 2129 if (sock->sk->sk_family == PF_INET6) 2130 smk_ipv6_port_label(sock, NULL); 2131 2132 return 0; 2133 } 2134 2135 /** 2136 * smack_socket_post_create - finish socket setup 2137 * @sock: the socket 2138 * @family: protocol family 2139 * @type: unused 2140 * @protocol: unused 2141 * @kern: unused 2142 * 2143 * Sets the netlabel information on the socket 2144 * 2145 * Returns 0 on success, and error code otherwise 2146 */ 2147 static int smack_socket_post_create(struct socket *sock, int family, 2148 int type, int protocol, int kern) 2149 { 2150 if (family != PF_INET || sock->sk == NULL) 2151 return 0; 2152 /* 2153 * Set the outbound netlbl. 2154 */ 2155 return smack_netlabel(sock->sk, SMACK_CIPSO_SOCKET); 2156 } 2157 2158 /** 2159 * smack_socket_bind - record port binding information. 2160 * @sock: the socket 2161 * @address: the port address 2162 * @addrlen: size of the address 2163 * 2164 * Records the label bound to a port. 2165 * 2166 * Returns 0 2167 */ 2168 static int smack_socket_bind(struct socket *sock, struct sockaddr *address, 2169 int addrlen) 2170 { 2171 if (sock->sk != NULL && sock->sk->sk_family == PF_INET6) 2172 smk_ipv6_port_label(sock, address); 2173 2174 return 0; 2175 } 2176 2177 /** 2178 * smack_socket_connect - connect access check 2179 * @sock: the socket 2180 * @sap: the other end 2181 * @addrlen: size of sap 2182 * 2183 * Verifies that a connection may be possible 2184 * 2185 * Returns 0 on success, and error code otherwise 2186 */ 2187 static int smack_socket_connect(struct socket *sock, struct sockaddr *sap, 2188 int addrlen) 2189 { 2190 int rc = 0; 2191 2192 if (sock->sk == NULL) 2193 return 0; 2194 2195 switch (sock->sk->sk_family) { 2196 case PF_INET: 2197 if (addrlen < sizeof(struct sockaddr_in)) 2198 return -EINVAL; 2199 rc = smack_netlabel_send(sock->sk, (struct sockaddr_in *)sap); 2200 break; 2201 case PF_INET6: 2202 if (addrlen < sizeof(struct sockaddr_in6)) 2203 return -EINVAL; 2204 rc = smk_ipv6_port_check(sock->sk, sap, SMK_CONNECTING); 2205 break; 2206 } 2207 return rc; 2208 } 2209 2210 /** 2211 * smack_flags_to_may - convert S_ to MAY_ values 2212 * @flags: the S_ value 2213 * 2214 * Returns the equivalent MAY_ value 2215 */ 2216 static int smack_flags_to_may(int flags) 2217 { 2218 int may = 0; 2219 2220 if (flags & S_IRUGO) 2221 may |= MAY_READ; 2222 if (flags & S_IWUGO) 2223 may |= MAY_WRITE; 2224 if (flags & S_IXUGO) 2225 may |= MAY_EXEC; 2226 2227 return may; 2228 } 2229 2230 /** 2231 * smack_msg_msg_alloc_security - Set the security blob for msg_msg 2232 * @msg: the object 2233 * 2234 * Returns 0 2235 */ 2236 static int smack_msg_msg_alloc_security(struct msg_msg *msg) 2237 { 2238 struct smack_known *skp = smk_of_current(); 2239 2240 msg->security = skp->smk_known; 2241 return 0; 2242 } 2243 2244 /** 2245 * smack_msg_msg_free_security - Clear the security blob for msg_msg 2246 * @msg: the object 2247 * 2248 * Clears the blob pointer 2249 */ 2250 static void smack_msg_msg_free_security(struct msg_msg *msg) 2251 { 2252 msg->security = NULL; 2253 } 2254 2255 /** 2256 * smack_of_shm - the smack pointer for the shm 2257 * @shp: the object 2258 * 2259 * Returns a pointer to the smack value 2260 */ 2261 static char *smack_of_shm(struct shmid_kernel *shp) 2262 { 2263 return (char *)shp->shm_perm.security; 2264 } 2265 2266 /** 2267 * smack_shm_alloc_security - Set the security blob for shm 2268 * @shp: the object 2269 * 2270 * Returns 0 2271 */ 2272 static int smack_shm_alloc_security(struct shmid_kernel *shp) 2273 { 2274 struct kern_ipc_perm *isp = &shp->shm_perm; 2275 struct smack_known *skp = smk_of_current(); 2276 2277 isp->security = skp->smk_known; 2278 return 0; 2279 } 2280 2281 /** 2282 * smack_shm_free_security - Clear the security blob for shm 2283 * @shp: the object 2284 * 2285 * Clears the blob pointer 2286 */ 2287 static void smack_shm_free_security(struct shmid_kernel *shp) 2288 { 2289 struct kern_ipc_perm *isp = &shp->shm_perm; 2290 2291 isp->security = NULL; 2292 } 2293 2294 /** 2295 * smk_curacc_shm : check if current has access on shm 2296 * @shp : the object 2297 * @access : access requested 2298 * 2299 * Returns 0 if current has the requested access, error code otherwise 2300 */ 2301 static int smk_curacc_shm(struct shmid_kernel *shp, int access) 2302 { 2303 char *ssp = smack_of_shm(shp); 2304 struct smk_audit_info ad; 2305 2306 #ifdef CONFIG_AUDIT 2307 smk_ad_init(&ad, __func__, LSM_AUDIT_DATA_IPC); 2308 ad.a.u.ipc_id = shp->shm_perm.id; 2309 #endif 2310 return smk_curacc(ssp, access, &ad); 2311 } 2312 2313 /** 2314 * smack_shm_associate - Smack access check for shm 2315 * @shp: the object 2316 * @shmflg: access requested 2317 * 2318 * Returns 0 if current has the requested access, error code otherwise 2319 */ 2320 static int smack_shm_associate(struct shmid_kernel *shp, int shmflg) 2321 { 2322 int may; 2323 2324 may = smack_flags_to_may(shmflg); 2325 return smk_curacc_shm(shp, may); 2326 } 2327 2328 /** 2329 * smack_shm_shmctl - Smack access check for shm 2330 * @shp: the object 2331 * @cmd: what it wants to do 2332 * 2333 * Returns 0 if current has the requested access, error code otherwise 2334 */ 2335 static int smack_shm_shmctl(struct shmid_kernel *shp, int cmd) 2336 { 2337 int may; 2338 2339 switch (cmd) { 2340 case IPC_STAT: 2341 case SHM_STAT: 2342 may = MAY_READ; 2343 break; 2344 case IPC_SET: 2345 case SHM_LOCK: 2346 case SHM_UNLOCK: 2347 case IPC_RMID: 2348 may = MAY_READWRITE; 2349 break; 2350 case IPC_INFO: 2351 case SHM_INFO: 2352 /* 2353 * System level information. 2354 */ 2355 return 0; 2356 default: 2357 return -EINVAL; 2358 } 2359 return smk_curacc_shm(shp, may); 2360 } 2361 2362 /** 2363 * smack_shm_shmat - Smack access for shmat 2364 * @shp: the object 2365 * @shmaddr: unused 2366 * @shmflg: access requested 2367 * 2368 * Returns 0 if current has the requested access, error code otherwise 2369 */ 2370 static int smack_shm_shmat(struct shmid_kernel *shp, char __user *shmaddr, 2371 int shmflg) 2372 { 2373 int may; 2374 2375 may = smack_flags_to_may(shmflg); 2376 return smk_curacc_shm(shp, may); 2377 } 2378 2379 /** 2380 * smack_of_sem - the smack pointer for the sem 2381 * @sma: the object 2382 * 2383 * Returns a pointer to the smack value 2384 */ 2385 static char *smack_of_sem(struct sem_array *sma) 2386 { 2387 return (char *)sma->sem_perm.security; 2388 } 2389 2390 /** 2391 * smack_sem_alloc_security - Set the security blob for sem 2392 * @sma: the object 2393 * 2394 * Returns 0 2395 */ 2396 static int smack_sem_alloc_security(struct sem_array *sma) 2397 { 2398 struct kern_ipc_perm *isp = &sma->sem_perm; 2399 struct smack_known *skp = smk_of_current(); 2400 2401 isp->security = skp->smk_known; 2402 return 0; 2403 } 2404 2405 /** 2406 * smack_sem_free_security - Clear the security blob for sem 2407 * @sma: the object 2408 * 2409 * Clears the blob pointer 2410 */ 2411 static void smack_sem_free_security(struct sem_array *sma) 2412 { 2413 struct kern_ipc_perm *isp = &sma->sem_perm; 2414 2415 isp->security = NULL; 2416 } 2417 2418 /** 2419 * smk_curacc_sem : check if current has access on sem 2420 * @sma : the object 2421 * @access : access requested 2422 * 2423 * Returns 0 if current has the requested access, error code otherwise 2424 */ 2425 static int smk_curacc_sem(struct sem_array *sma, int access) 2426 { 2427 char *ssp = smack_of_sem(sma); 2428 struct smk_audit_info ad; 2429 2430 #ifdef CONFIG_AUDIT 2431 smk_ad_init(&ad, __func__, LSM_AUDIT_DATA_IPC); 2432 ad.a.u.ipc_id = sma->sem_perm.id; 2433 #endif 2434 return smk_curacc(ssp, access, &ad); 2435 } 2436 2437 /** 2438 * smack_sem_associate - Smack access check for sem 2439 * @sma: the object 2440 * @semflg: access requested 2441 * 2442 * Returns 0 if current has the requested access, error code otherwise 2443 */ 2444 static int smack_sem_associate(struct sem_array *sma, int semflg) 2445 { 2446 int may; 2447 2448 may = smack_flags_to_may(semflg); 2449 return smk_curacc_sem(sma, may); 2450 } 2451 2452 /** 2453 * smack_sem_shmctl - Smack access check for sem 2454 * @sma: the object 2455 * @cmd: what it wants to do 2456 * 2457 * Returns 0 if current has the requested access, error code otherwise 2458 */ 2459 static int smack_sem_semctl(struct sem_array *sma, int cmd) 2460 { 2461 int may; 2462 2463 switch (cmd) { 2464 case GETPID: 2465 case GETNCNT: 2466 case GETZCNT: 2467 case GETVAL: 2468 case GETALL: 2469 case IPC_STAT: 2470 case SEM_STAT: 2471 may = MAY_READ; 2472 break; 2473 case SETVAL: 2474 case SETALL: 2475 case IPC_RMID: 2476 case IPC_SET: 2477 may = MAY_READWRITE; 2478 break; 2479 case IPC_INFO: 2480 case SEM_INFO: 2481 /* 2482 * System level information 2483 */ 2484 return 0; 2485 default: 2486 return -EINVAL; 2487 } 2488 2489 return smk_curacc_sem(sma, may); 2490 } 2491 2492 /** 2493 * smack_sem_semop - Smack checks of semaphore operations 2494 * @sma: the object 2495 * @sops: unused 2496 * @nsops: unused 2497 * @alter: unused 2498 * 2499 * Treated as read and write in all cases. 2500 * 2501 * Returns 0 if access is allowed, error code otherwise 2502 */ 2503 static int smack_sem_semop(struct sem_array *sma, struct sembuf *sops, 2504 unsigned nsops, int alter) 2505 { 2506 return smk_curacc_sem(sma, MAY_READWRITE); 2507 } 2508 2509 /** 2510 * smack_msg_alloc_security - Set the security blob for msg 2511 * @msq: the object 2512 * 2513 * Returns 0 2514 */ 2515 static int smack_msg_queue_alloc_security(struct msg_queue *msq) 2516 { 2517 struct kern_ipc_perm *kisp = &msq->q_perm; 2518 struct smack_known *skp = smk_of_current(); 2519 2520 kisp->security = skp->smk_known; 2521 return 0; 2522 } 2523 2524 /** 2525 * smack_msg_free_security - Clear the security blob for msg 2526 * @msq: the object 2527 * 2528 * Clears the blob pointer 2529 */ 2530 static void smack_msg_queue_free_security(struct msg_queue *msq) 2531 { 2532 struct kern_ipc_perm *kisp = &msq->q_perm; 2533 2534 kisp->security = NULL; 2535 } 2536 2537 /** 2538 * smack_of_msq - the smack pointer for the msq 2539 * @msq: the object 2540 * 2541 * Returns a pointer to the smack value 2542 */ 2543 static char *smack_of_msq(struct msg_queue *msq) 2544 { 2545 return (char *)msq->q_perm.security; 2546 } 2547 2548 /** 2549 * smk_curacc_msq : helper to check if current has access on msq 2550 * @msq : the msq 2551 * @access : access requested 2552 * 2553 * return 0 if current has access, error otherwise 2554 */ 2555 static int smk_curacc_msq(struct msg_queue *msq, int access) 2556 { 2557 char *msp = smack_of_msq(msq); 2558 struct smk_audit_info ad; 2559 2560 #ifdef CONFIG_AUDIT 2561 smk_ad_init(&ad, __func__, LSM_AUDIT_DATA_IPC); 2562 ad.a.u.ipc_id = msq->q_perm.id; 2563 #endif 2564 return smk_curacc(msp, access, &ad); 2565 } 2566 2567 /** 2568 * smack_msg_queue_associate - Smack access check for msg_queue 2569 * @msq: the object 2570 * @msqflg: access requested 2571 * 2572 * Returns 0 if current has the requested access, error code otherwise 2573 */ 2574 static int smack_msg_queue_associate(struct msg_queue *msq, int msqflg) 2575 { 2576 int may; 2577 2578 may = smack_flags_to_may(msqflg); 2579 return smk_curacc_msq(msq, may); 2580 } 2581 2582 /** 2583 * smack_msg_queue_msgctl - Smack access check for msg_queue 2584 * @msq: the object 2585 * @cmd: what it wants to do 2586 * 2587 * Returns 0 if current has the requested access, error code otherwise 2588 */ 2589 static int smack_msg_queue_msgctl(struct msg_queue *msq, int cmd) 2590 { 2591 int may; 2592 2593 switch (cmd) { 2594 case IPC_STAT: 2595 case MSG_STAT: 2596 may = MAY_READ; 2597 break; 2598 case IPC_SET: 2599 case IPC_RMID: 2600 may = MAY_READWRITE; 2601 break; 2602 case IPC_INFO: 2603 case MSG_INFO: 2604 /* 2605 * System level information 2606 */ 2607 return 0; 2608 default: 2609 return -EINVAL; 2610 } 2611 2612 return smk_curacc_msq(msq, may); 2613 } 2614 2615 /** 2616 * smack_msg_queue_msgsnd - Smack access check for msg_queue 2617 * @msq: the object 2618 * @msg: unused 2619 * @msqflg: access requested 2620 * 2621 * Returns 0 if current has the requested access, error code otherwise 2622 */ 2623 static int smack_msg_queue_msgsnd(struct msg_queue *msq, struct msg_msg *msg, 2624 int msqflg) 2625 { 2626 int may; 2627 2628 may = smack_flags_to_may(msqflg); 2629 return smk_curacc_msq(msq, may); 2630 } 2631 2632 /** 2633 * smack_msg_queue_msgsnd - Smack access check for msg_queue 2634 * @msq: the object 2635 * @msg: unused 2636 * @target: unused 2637 * @type: unused 2638 * @mode: unused 2639 * 2640 * Returns 0 if current has read and write access, error code otherwise 2641 */ 2642 static int smack_msg_queue_msgrcv(struct msg_queue *msq, struct msg_msg *msg, 2643 struct task_struct *target, long type, int mode) 2644 { 2645 return smk_curacc_msq(msq, MAY_READWRITE); 2646 } 2647 2648 /** 2649 * smack_ipc_permission - Smack access for ipc_permission() 2650 * @ipp: the object permissions 2651 * @flag: access requested 2652 * 2653 * Returns 0 if current has read and write access, error code otherwise 2654 */ 2655 static int smack_ipc_permission(struct kern_ipc_perm *ipp, short flag) 2656 { 2657 char *isp = ipp->security; 2658 int may = smack_flags_to_may(flag); 2659 struct smk_audit_info ad; 2660 2661 #ifdef CONFIG_AUDIT 2662 smk_ad_init(&ad, __func__, LSM_AUDIT_DATA_IPC); 2663 ad.a.u.ipc_id = ipp->id; 2664 #endif 2665 return smk_curacc(isp, may, &ad); 2666 } 2667 2668 /** 2669 * smack_ipc_getsecid - Extract smack security id 2670 * @ipp: the object permissions 2671 * @secid: where result will be saved 2672 */ 2673 static void smack_ipc_getsecid(struct kern_ipc_perm *ipp, u32 *secid) 2674 { 2675 char *smack = ipp->security; 2676 2677 *secid = smack_to_secid(smack); 2678 } 2679 2680 /** 2681 * smack_d_instantiate - Make sure the blob is correct on an inode 2682 * @opt_dentry: dentry where inode will be attached 2683 * @inode: the object 2684 * 2685 * Set the inode's security blob if it hasn't been done already. 2686 */ 2687 static void smack_d_instantiate(struct dentry *opt_dentry, struct inode *inode) 2688 { 2689 struct super_block *sbp; 2690 struct superblock_smack *sbsp; 2691 struct inode_smack *isp; 2692 struct smack_known *skp; 2693 struct smack_known *ckp = smk_of_current(); 2694 char *final; 2695 char trattr[TRANS_TRUE_SIZE]; 2696 int transflag = 0; 2697 int rc; 2698 struct dentry *dp; 2699 2700 if (inode == NULL) 2701 return; 2702 2703 isp = inode->i_security; 2704 2705 mutex_lock(&isp->smk_lock); 2706 /* 2707 * If the inode is already instantiated 2708 * take the quick way out 2709 */ 2710 if (isp->smk_flags & SMK_INODE_INSTANT) 2711 goto unlockandout; 2712 2713 sbp = inode->i_sb; 2714 sbsp = sbp->s_security; 2715 /* 2716 * We're going to use the superblock default label 2717 * if there's no label on the file. 2718 */ 2719 final = sbsp->smk_default; 2720 2721 /* 2722 * If this is the root inode the superblock 2723 * may be in the process of initialization. 2724 * If that is the case use the root value out 2725 * of the superblock. 2726 */ 2727 if (opt_dentry->d_parent == opt_dentry) { 2728 isp->smk_inode = sbsp->smk_root; 2729 isp->smk_flags |= SMK_INODE_INSTANT; 2730 goto unlockandout; 2731 } 2732 2733 /* 2734 * This is pretty hackish. 2735 * Casey says that we shouldn't have to do 2736 * file system specific code, but it does help 2737 * with keeping it simple. 2738 */ 2739 switch (sbp->s_magic) { 2740 case SMACK_MAGIC: 2741 /* 2742 * Casey says that it's a little embarrassing 2743 * that the smack file system doesn't do 2744 * extended attributes. 2745 */ 2746 final = smack_known_star.smk_known; 2747 break; 2748 case PIPEFS_MAGIC: 2749 /* 2750 * Casey says pipes are easy (?) 2751 */ 2752 final = smack_known_star.smk_known; 2753 break; 2754 case DEVPTS_SUPER_MAGIC: 2755 /* 2756 * devpts seems content with the label of the task. 2757 * Programs that change smack have to treat the 2758 * pty with respect. 2759 */ 2760 final = ckp->smk_known; 2761 break; 2762 case SOCKFS_MAGIC: 2763 /* 2764 * Socket access is controlled by the socket 2765 * structures associated with the task involved. 2766 */ 2767 final = smack_known_star.smk_known; 2768 break; 2769 case PROC_SUPER_MAGIC: 2770 /* 2771 * Casey says procfs appears not to care. 2772 * The superblock default suffices. 2773 */ 2774 break; 2775 case TMPFS_MAGIC: 2776 /* 2777 * Device labels should come from the filesystem, 2778 * but watch out, because they're volitile, 2779 * getting recreated on every reboot. 2780 */ 2781 final = smack_known_star.smk_known; 2782 /* 2783 * No break. 2784 * 2785 * If a smack value has been set we want to use it, 2786 * but since tmpfs isn't giving us the opportunity 2787 * to set mount options simulate setting the 2788 * superblock default. 2789 */ 2790 default: 2791 /* 2792 * This isn't an understood special case. 2793 * Get the value from the xattr. 2794 */ 2795 2796 /* 2797 * UNIX domain sockets use lower level socket data. 2798 */ 2799 if (S_ISSOCK(inode->i_mode)) { 2800 final = smack_known_star.smk_known; 2801 break; 2802 } 2803 /* 2804 * No xattr support means, alas, no SMACK label. 2805 * Use the aforeapplied default. 2806 * It would be curious if the label of the task 2807 * does not match that assigned. 2808 */ 2809 if (inode->i_op->getxattr == NULL) 2810 break; 2811 /* 2812 * Get the dentry for xattr. 2813 */ 2814 dp = dget(opt_dentry); 2815 skp = smk_fetch(XATTR_NAME_SMACK, inode, dp); 2816 if (skp != NULL) 2817 final = skp->smk_known; 2818 2819 /* 2820 * Transmuting directory 2821 */ 2822 if (S_ISDIR(inode->i_mode)) { 2823 /* 2824 * If this is a new directory and the label was 2825 * transmuted when the inode was initialized 2826 * set the transmute attribute on the directory 2827 * and mark the inode. 2828 * 2829 * If there is a transmute attribute on the 2830 * directory mark the inode. 2831 */ 2832 if (isp->smk_flags & SMK_INODE_CHANGED) { 2833 isp->smk_flags &= ~SMK_INODE_CHANGED; 2834 rc = inode->i_op->setxattr(dp, 2835 XATTR_NAME_SMACKTRANSMUTE, 2836 TRANS_TRUE, TRANS_TRUE_SIZE, 2837 0); 2838 } else { 2839 rc = inode->i_op->getxattr(dp, 2840 XATTR_NAME_SMACKTRANSMUTE, trattr, 2841 TRANS_TRUE_SIZE); 2842 if (rc >= 0 && strncmp(trattr, TRANS_TRUE, 2843 TRANS_TRUE_SIZE) != 0) 2844 rc = -EINVAL; 2845 } 2846 if (rc >= 0) 2847 transflag = SMK_INODE_TRANSMUTE; 2848 } 2849 isp->smk_task = smk_fetch(XATTR_NAME_SMACKEXEC, inode, dp); 2850 isp->smk_mmap = smk_fetch(XATTR_NAME_SMACKMMAP, inode, dp); 2851 2852 dput(dp); 2853 break; 2854 } 2855 2856 if (final == NULL) 2857 isp->smk_inode = ckp->smk_known; 2858 else 2859 isp->smk_inode = final; 2860 2861 isp->smk_flags |= (SMK_INODE_INSTANT | transflag); 2862 2863 unlockandout: 2864 mutex_unlock(&isp->smk_lock); 2865 return; 2866 } 2867 2868 /** 2869 * smack_getprocattr - Smack process attribute access 2870 * @p: the object task 2871 * @name: the name of the attribute in /proc/.../attr 2872 * @value: where to put the result 2873 * 2874 * Places a copy of the task Smack into value 2875 * 2876 * Returns the length of the smack label or an error code 2877 */ 2878 static int smack_getprocattr(struct task_struct *p, char *name, char **value) 2879 { 2880 struct smack_known *skp = smk_of_task(task_security(p)); 2881 char *cp; 2882 int slen; 2883 2884 if (strcmp(name, "current") != 0) 2885 return -EINVAL; 2886 2887 cp = kstrdup(skp->smk_known, GFP_KERNEL); 2888 if (cp == NULL) 2889 return -ENOMEM; 2890 2891 slen = strlen(cp); 2892 *value = cp; 2893 return slen; 2894 } 2895 2896 /** 2897 * smack_setprocattr - Smack process attribute setting 2898 * @p: the object task 2899 * @name: the name of the attribute in /proc/.../attr 2900 * @value: the value to set 2901 * @size: the size of the value 2902 * 2903 * Sets the Smack value of the task. Only setting self 2904 * is permitted and only with privilege 2905 * 2906 * Returns the length of the smack label or an error code 2907 */ 2908 static int smack_setprocattr(struct task_struct *p, char *name, 2909 void *value, size_t size) 2910 { 2911 struct task_smack *tsp; 2912 struct cred *new; 2913 struct smack_known *skp; 2914 2915 /* 2916 * Changing another process' Smack value is too dangerous 2917 * and supports no sane use case. 2918 */ 2919 if (p != current) 2920 return -EPERM; 2921 2922 if (!smack_privileged(CAP_MAC_ADMIN)) 2923 return -EPERM; 2924 2925 if (value == NULL || size == 0 || size >= SMK_LONGLABEL) 2926 return -EINVAL; 2927 2928 if (strcmp(name, "current") != 0) 2929 return -EINVAL; 2930 2931 skp = smk_import_entry(value, size); 2932 if (skp == NULL) 2933 return -EINVAL; 2934 2935 /* 2936 * No process is ever allowed the web ("@") label. 2937 */ 2938 if (skp == &smack_known_web) 2939 return -EPERM; 2940 2941 new = prepare_creds(); 2942 if (new == NULL) 2943 return -ENOMEM; 2944 2945 tsp = new->security; 2946 tsp->smk_task = skp; 2947 2948 commit_creds(new); 2949 return size; 2950 } 2951 2952 /** 2953 * smack_unix_stream_connect - Smack access on UDS 2954 * @sock: one sock 2955 * @other: the other sock 2956 * @newsk: unused 2957 * 2958 * Return 0 if a subject with the smack of sock could access 2959 * an object with the smack of other, otherwise an error code 2960 */ 2961 static int smack_unix_stream_connect(struct sock *sock, 2962 struct sock *other, struct sock *newsk) 2963 { 2964 struct smack_known *skp; 2965 struct socket_smack *ssp = sock->sk_security; 2966 struct socket_smack *osp = other->sk_security; 2967 struct socket_smack *nsp = newsk->sk_security; 2968 struct smk_audit_info ad; 2969 int rc = 0; 2970 2971 #ifdef CONFIG_AUDIT 2972 struct lsm_network_audit net; 2973 2974 smk_ad_init_net(&ad, __func__, LSM_AUDIT_DATA_NET, &net); 2975 smk_ad_setfield_u_net_sk(&ad, other); 2976 #endif 2977 2978 if (!smack_privileged(CAP_MAC_OVERRIDE)) { 2979 skp = ssp->smk_out; 2980 rc = smk_access(skp, osp->smk_in, MAY_WRITE, &ad); 2981 } 2982 2983 /* 2984 * Cross reference the peer labels for SO_PEERSEC. 2985 */ 2986 if (rc == 0) { 2987 nsp->smk_packet = ssp->smk_out->smk_known; 2988 ssp->smk_packet = osp->smk_out->smk_known; 2989 } 2990 2991 return rc; 2992 } 2993 2994 /** 2995 * smack_unix_may_send - Smack access on UDS 2996 * @sock: one socket 2997 * @other: the other socket 2998 * 2999 * Return 0 if a subject with the smack of sock could access 3000 * an object with the smack of other, otherwise an error code 3001 */ 3002 static int smack_unix_may_send(struct socket *sock, struct socket *other) 3003 { 3004 struct socket_smack *ssp = sock->sk->sk_security; 3005 struct socket_smack *osp = other->sk->sk_security; 3006 struct smack_known *skp; 3007 struct smk_audit_info ad; 3008 3009 #ifdef CONFIG_AUDIT 3010 struct lsm_network_audit net; 3011 3012 smk_ad_init_net(&ad, __func__, LSM_AUDIT_DATA_NET, &net); 3013 smk_ad_setfield_u_net_sk(&ad, other->sk); 3014 #endif 3015 3016 if (smack_privileged(CAP_MAC_OVERRIDE)) 3017 return 0; 3018 3019 skp = ssp->smk_out; 3020 return smk_access(skp, osp->smk_in, MAY_WRITE, &ad); 3021 } 3022 3023 /** 3024 * smack_socket_sendmsg - Smack check based on destination host 3025 * @sock: the socket 3026 * @msg: the message 3027 * @size: the size of the message 3028 * 3029 * Return 0 if the current subject can write to the destination host. 3030 * For IPv4 this is only a question if the destination is a single label host. 3031 * For IPv6 this is a check against the label of the port. 3032 */ 3033 static int smack_socket_sendmsg(struct socket *sock, struct msghdr *msg, 3034 int size) 3035 { 3036 struct sockaddr_in *sip = (struct sockaddr_in *) msg->msg_name; 3037 struct sockaddr *sap = (struct sockaddr *) msg->msg_name; 3038 int rc = 0; 3039 3040 /* 3041 * Perfectly reasonable for this to be NULL 3042 */ 3043 if (sip == NULL) 3044 return 0; 3045 3046 switch (sip->sin_family) { 3047 case AF_INET: 3048 rc = smack_netlabel_send(sock->sk, sip); 3049 break; 3050 case AF_INET6: 3051 rc = smk_ipv6_port_check(sock->sk, sap, SMK_SENDING); 3052 break; 3053 } 3054 return rc; 3055 } 3056 3057 /** 3058 * smack_from_secattr - Convert a netlabel attr.mls.lvl/attr.mls.cat pair to smack 3059 * @sap: netlabel secattr 3060 * @ssp: socket security information 3061 * 3062 * Returns a pointer to a Smack label entry found on the label list. 3063 */ 3064 static struct smack_known *smack_from_secattr(struct netlbl_lsm_secattr *sap, 3065 struct socket_smack *ssp) 3066 { 3067 struct smack_known *skp; 3068 int found = 0; 3069 3070 if ((sap->flags & NETLBL_SECATTR_MLS_LVL) != 0) { 3071 /* 3072 * Looks like a CIPSO packet. 3073 * If there are flags but no level netlabel isn't 3074 * behaving the way we expect it to. 3075 * 3076 * Look it up in the label table 3077 * Without guidance regarding the smack value 3078 * for the packet fall back on the network 3079 * ambient value. 3080 */ 3081 rcu_read_lock(); 3082 list_for_each_entry(skp, &smack_known_list, list) { 3083 if (sap->attr.mls.lvl != skp->smk_netlabel.attr.mls.lvl) 3084 continue; 3085 if (memcmp(sap->attr.mls.cat, 3086 skp->smk_netlabel.attr.mls.cat, 3087 SMK_CIPSOLEN) != 0) 3088 continue; 3089 found = 1; 3090 break; 3091 } 3092 rcu_read_unlock(); 3093 3094 if (found) 3095 return skp; 3096 3097 if (ssp != NULL && ssp->smk_in == smack_known_star.smk_known) 3098 return &smack_known_web; 3099 return &smack_known_star; 3100 } 3101 if ((sap->flags & NETLBL_SECATTR_SECID) != 0) { 3102 /* 3103 * Looks like a fallback, which gives us a secid. 3104 */ 3105 skp = smack_from_secid(sap->attr.secid); 3106 /* 3107 * This has got to be a bug because it is 3108 * impossible to specify a fallback without 3109 * specifying the label, which will ensure 3110 * it has a secid, and the only way to get a 3111 * secid is from a fallback. 3112 */ 3113 BUG_ON(skp == NULL); 3114 return skp; 3115 } 3116 /* 3117 * Without guidance regarding the smack value 3118 * for the packet fall back on the network 3119 * ambient value. 3120 */ 3121 return smack_net_ambient; 3122 } 3123 3124 static int smk_skb_to_addr_ipv6(struct sk_buff *skb, struct sockaddr *sap) 3125 { 3126 struct sockaddr_in6 *sip = (struct sockaddr_in6 *)sap; 3127 u8 nexthdr; 3128 int offset; 3129 int proto = -EINVAL; 3130 struct ipv6hdr _ipv6h; 3131 struct ipv6hdr *ip6; 3132 __be16 frag_off; 3133 struct tcphdr _tcph, *th; 3134 struct udphdr _udph, *uh; 3135 struct dccp_hdr _dccph, *dh; 3136 3137 sip->sin6_port = 0; 3138 3139 offset = skb_network_offset(skb); 3140 ip6 = skb_header_pointer(skb, offset, sizeof(_ipv6h), &_ipv6h); 3141 if (ip6 == NULL) 3142 return -EINVAL; 3143 sip->sin6_addr = ip6->saddr; 3144 3145 nexthdr = ip6->nexthdr; 3146 offset += sizeof(_ipv6h); 3147 offset = ipv6_skip_exthdr(skb, offset, &nexthdr, &frag_off); 3148 if (offset < 0) 3149 return -EINVAL; 3150 3151 proto = nexthdr; 3152 switch (proto) { 3153 case IPPROTO_TCP: 3154 th = skb_header_pointer(skb, offset, sizeof(_tcph), &_tcph); 3155 if (th != NULL) 3156 sip->sin6_port = th->source; 3157 break; 3158 case IPPROTO_UDP: 3159 uh = skb_header_pointer(skb, offset, sizeof(_udph), &_udph); 3160 if (uh != NULL) 3161 sip->sin6_port = uh->source; 3162 break; 3163 case IPPROTO_DCCP: 3164 dh = skb_header_pointer(skb, offset, sizeof(_dccph), &_dccph); 3165 if (dh != NULL) 3166 sip->sin6_port = dh->dccph_sport; 3167 break; 3168 } 3169 return proto; 3170 } 3171 3172 /** 3173 * smack_socket_sock_rcv_skb - Smack packet delivery access check 3174 * @sk: socket 3175 * @skb: packet 3176 * 3177 * Returns 0 if the packet should be delivered, an error code otherwise 3178 */ 3179 static int smack_socket_sock_rcv_skb(struct sock *sk, struct sk_buff *skb) 3180 { 3181 struct netlbl_lsm_secattr secattr; 3182 struct socket_smack *ssp = sk->sk_security; 3183 struct smack_known *skp; 3184 struct sockaddr sadd; 3185 int rc = 0; 3186 struct smk_audit_info ad; 3187 #ifdef CONFIG_AUDIT 3188 struct lsm_network_audit net; 3189 #endif 3190 switch (sk->sk_family) { 3191 case PF_INET: 3192 /* 3193 * Translate what netlabel gave us. 3194 */ 3195 netlbl_secattr_init(&secattr); 3196 3197 rc = netlbl_skbuff_getattr(skb, sk->sk_family, &secattr); 3198 if (rc == 0) 3199 skp = smack_from_secattr(&secattr, ssp); 3200 else 3201 skp = smack_net_ambient; 3202 3203 netlbl_secattr_destroy(&secattr); 3204 3205 #ifdef CONFIG_AUDIT 3206 smk_ad_init_net(&ad, __func__, LSM_AUDIT_DATA_NET, &net); 3207 ad.a.u.net->family = sk->sk_family; 3208 ad.a.u.net->netif = skb->skb_iif; 3209 ipv4_skb_to_auditdata(skb, &ad.a, NULL); 3210 #endif 3211 /* 3212 * Receiving a packet requires that the other end 3213 * be able to write here. Read access is not required. 3214 * This is the simplist possible security model 3215 * for networking. 3216 */ 3217 rc = smk_access(skp, ssp->smk_in, MAY_WRITE, &ad); 3218 if (rc != 0) 3219 netlbl_skbuff_err(skb, rc, 0); 3220 break; 3221 case PF_INET6: 3222 rc = smk_skb_to_addr_ipv6(skb, &sadd); 3223 if (rc == IPPROTO_UDP || rc == IPPROTO_TCP) 3224 rc = smk_ipv6_port_check(sk, &sadd, SMK_RECEIVING); 3225 else 3226 rc = 0; 3227 break; 3228 } 3229 return rc; 3230 } 3231 3232 /** 3233 * smack_socket_getpeersec_stream - pull in packet label 3234 * @sock: the socket 3235 * @optval: user's destination 3236 * @optlen: size thereof 3237 * @len: max thereof 3238 * 3239 * returns zero on success, an error code otherwise 3240 */ 3241 static int smack_socket_getpeersec_stream(struct socket *sock, 3242 char __user *optval, 3243 int __user *optlen, unsigned len) 3244 { 3245 struct socket_smack *ssp; 3246 char *rcp = ""; 3247 int slen = 1; 3248 int rc = 0; 3249 3250 ssp = sock->sk->sk_security; 3251 if (ssp->smk_packet != NULL) { 3252 rcp = ssp->smk_packet; 3253 slen = strlen(rcp) + 1; 3254 } 3255 3256 if (slen > len) 3257 rc = -ERANGE; 3258 else if (copy_to_user(optval, rcp, slen) != 0) 3259 rc = -EFAULT; 3260 3261 if (put_user(slen, optlen) != 0) 3262 rc = -EFAULT; 3263 3264 return rc; 3265 } 3266 3267 3268 /** 3269 * smack_socket_getpeersec_dgram - pull in packet label 3270 * @sock: the peer socket 3271 * @skb: packet data 3272 * @secid: pointer to where to put the secid of the packet 3273 * 3274 * Sets the netlabel socket state on sk from parent 3275 */ 3276 static int smack_socket_getpeersec_dgram(struct socket *sock, 3277 struct sk_buff *skb, u32 *secid) 3278 3279 { 3280 struct netlbl_lsm_secattr secattr; 3281 struct socket_smack *ssp = NULL; 3282 struct smack_known *skp; 3283 int family = PF_UNSPEC; 3284 u32 s = 0; /* 0 is the invalid secid */ 3285 int rc; 3286 3287 if (skb != NULL) { 3288 if (skb->protocol == htons(ETH_P_IP)) 3289 family = PF_INET; 3290 else if (skb->protocol == htons(ETH_P_IPV6)) 3291 family = PF_INET6; 3292 } 3293 if (family == PF_UNSPEC && sock != NULL) 3294 family = sock->sk->sk_family; 3295 3296 if (family == PF_UNIX) { 3297 ssp = sock->sk->sk_security; 3298 s = ssp->smk_out->smk_secid; 3299 } else if (family == PF_INET || family == PF_INET6) { 3300 /* 3301 * Translate what netlabel gave us. 3302 */ 3303 if (sock != NULL && sock->sk != NULL) 3304 ssp = sock->sk->sk_security; 3305 netlbl_secattr_init(&secattr); 3306 rc = netlbl_skbuff_getattr(skb, family, &secattr); 3307 if (rc == 0) { 3308 skp = smack_from_secattr(&secattr, ssp); 3309 s = skp->smk_secid; 3310 } 3311 netlbl_secattr_destroy(&secattr); 3312 } 3313 *secid = s; 3314 if (s == 0) 3315 return -EINVAL; 3316 return 0; 3317 } 3318 3319 /** 3320 * smack_sock_graft - Initialize a newly created socket with an existing sock 3321 * @sk: child sock 3322 * @parent: parent socket 3323 * 3324 * Set the smk_{in,out} state of an existing sock based on the process that 3325 * is creating the new socket. 3326 */ 3327 static void smack_sock_graft(struct sock *sk, struct socket *parent) 3328 { 3329 struct socket_smack *ssp; 3330 struct smack_known *skp = smk_of_current(); 3331 3332 if (sk == NULL || 3333 (sk->sk_family != PF_INET && sk->sk_family != PF_INET6)) 3334 return; 3335 3336 ssp = sk->sk_security; 3337 ssp->smk_in = skp->smk_known; 3338 ssp->smk_out = skp; 3339 /* cssp->smk_packet is already set in smack_inet_csk_clone() */ 3340 } 3341 3342 /** 3343 * smack_inet_conn_request - Smack access check on connect 3344 * @sk: socket involved 3345 * @skb: packet 3346 * @req: unused 3347 * 3348 * Returns 0 if a task with the packet label could write to 3349 * the socket, otherwise an error code 3350 */ 3351 static int smack_inet_conn_request(struct sock *sk, struct sk_buff *skb, 3352 struct request_sock *req) 3353 { 3354 u16 family = sk->sk_family; 3355 struct smack_known *skp; 3356 struct socket_smack *ssp = sk->sk_security; 3357 struct netlbl_lsm_secattr secattr; 3358 struct sockaddr_in addr; 3359 struct iphdr *hdr; 3360 char *hsp; 3361 int rc; 3362 struct smk_audit_info ad; 3363 #ifdef CONFIG_AUDIT 3364 struct lsm_network_audit net; 3365 #endif 3366 3367 if (family == PF_INET6) { 3368 /* 3369 * Handle mapped IPv4 packets arriving 3370 * via IPv6 sockets. Don't set up netlabel 3371 * processing on IPv6. 3372 */ 3373 if (skb->protocol == htons(ETH_P_IP)) 3374 family = PF_INET; 3375 else 3376 return 0; 3377 } 3378 3379 netlbl_secattr_init(&secattr); 3380 rc = netlbl_skbuff_getattr(skb, family, &secattr); 3381 if (rc == 0) 3382 skp = smack_from_secattr(&secattr, ssp); 3383 else 3384 skp = &smack_known_huh; 3385 netlbl_secattr_destroy(&secattr); 3386 3387 #ifdef CONFIG_AUDIT 3388 smk_ad_init_net(&ad, __func__, LSM_AUDIT_DATA_NET, &net); 3389 ad.a.u.net->family = family; 3390 ad.a.u.net->netif = skb->skb_iif; 3391 ipv4_skb_to_auditdata(skb, &ad.a, NULL); 3392 #endif 3393 /* 3394 * Receiving a packet requires that the other end be able to write 3395 * here. Read access is not required. 3396 */ 3397 rc = smk_access(skp, ssp->smk_in, MAY_WRITE, &ad); 3398 if (rc != 0) 3399 return rc; 3400 3401 /* 3402 * Save the peer's label in the request_sock so we can later setup 3403 * smk_packet in the child socket so that SO_PEERCRED can report it. 3404 */ 3405 req->peer_secid = skp->smk_secid; 3406 3407 /* 3408 * We need to decide if we want to label the incoming connection here 3409 * if we do we only need to label the request_sock and the stack will 3410 * propagate the wire-label to the sock when it is created. 3411 */ 3412 hdr = ip_hdr(skb); 3413 addr.sin_addr.s_addr = hdr->saddr; 3414 rcu_read_lock(); 3415 hsp = smack_host_label(&addr); 3416 rcu_read_unlock(); 3417 3418 if (hsp == NULL) 3419 rc = netlbl_req_setattr(req, &skp->smk_netlabel); 3420 else 3421 netlbl_req_delattr(req); 3422 3423 return rc; 3424 } 3425 3426 /** 3427 * smack_inet_csk_clone - Copy the connection information to the new socket 3428 * @sk: the new socket 3429 * @req: the connection's request_sock 3430 * 3431 * Transfer the connection's peer label to the newly created socket. 3432 */ 3433 static void smack_inet_csk_clone(struct sock *sk, 3434 const struct request_sock *req) 3435 { 3436 struct socket_smack *ssp = sk->sk_security; 3437 struct smack_known *skp; 3438 3439 if (req->peer_secid != 0) { 3440 skp = smack_from_secid(req->peer_secid); 3441 ssp->smk_packet = skp->smk_known; 3442 } else 3443 ssp->smk_packet = NULL; 3444 } 3445 3446 /* 3447 * Key management security hooks 3448 * 3449 * Casey has not tested key support very heavily. 3450 * The permission check is most likely too restrictive. 3451 * If you care about keys please have a look. 3452 */ 3453 #ifdef CONFIG_KEYS 3454 3455 /** 3456 * smack_key_alloc - Set the key security blob 3457 * @key: object 3458 * @cred: the credentials to use 3459 * @flags: unused 3460 * 3461 * No allocation required 3462 * 3463 * Returns 0 3464 */ 3465 static int smack_key_alloc(struct key *key, const struct cred *cred, 3466 unsigned long flags) 3467 { 3468 struct smack_known *skp = smk_of_task(cred->security); 3469 3470 key->security = skp->smk_known; 3471 return 0; 3472 } 3473 3474 /** 3475 * smack_key_free - Clear the key security blob 3476 * @key: the object 3477 * 3478 * Clear the blob pointer 3479 */ 3480 static void smack_key_free(struct key *key) 3481 { 3482 key->security = NULL; 3483 } 3484 3485 /* 3486 * smack_key_permission - Smack access on a key 3487 * @key_ref: gets to the object 3488 * @cred: the credentials to use 3489 * @perm: unused 3490 * 3491 * Return 0 if the task has read and write to the object, 3492 * an error code otherwise 3493 */ 3494 static int smack_key_permission(key_ref_t key_ref, 3495 const struct cred *cred, key_perm_t perm) 3496 { 3497 struct key *keyp; 3498 struct smk_audit_info ad; 3499 struct smack_known *tkp = smk_of_task(cred->security); 3500 3501 keyp = key_ref_to_ptr(key_ref); 3502 if (keyp == NULL) 3503 return -EINVAL; 3504 /* 3505 * If the key hasn't been initialized give it access so that 3506 * it may do so. 3507 */ 3508 if (keyp->security == NULL) 3509 return 0; 3510 /* 3511 * This should not occur 3512 */ 3513 if (tkp == NULL) 3514 return -EACCES; 3515 #ifdef CONFIG_AUDIT 3516 smk_ad_init(&ad, __func__, LSM_AUDIT_DATA_KEY); 3517 ad.a.u.key_struct.key = keyp->serial; 3518 ad.a.u.key_struct.key_desc = keyp->description; 3519 #endif 3520 return smk_access(tkp, keyp->security, MAY_READWRITE, &ad); 3521 } 3522 #endif /* CONFIG_KEYS */ 3523 3524 /* 3525 * Smack Audit hooks 3526 * 3527 * Audit requires a unique representation of each Smack specific 3528 * rule. This unique representation is used to distinguish the 3529 * object to be audited from remaining kernel objects and also 3530 * works as a glue between the audit hooks. 3531 * 3532 * Since repository entries are added but never deleted, we'll use 3533 * the smack_known label address related to the given audit rule as 3534 * the needed unique representation. This also better fits the smack 3535 * model where nearly everything is a label. 3536 */ 3537 #ifdef CONFIG_AUDIT 3538 3539 /** 3540 * smack_audit_rule_init - Initialize a smack audit rule 3541 * @field: audit rule fields given from user-space (audit.h) 3542 * @op: required testing operator (=, !=, >, <, ...) 3543 * @rulestr: smack label to be audited 3544 * @vrule: pointer to save our own audit rule representation 3545 * 3546 * Prepare to audit cases where (@field @op @rulestr) is true. 3547 * The label to be audited is created if necessay. 3548 */ 3549 static int smack_audit_rule_init(u32 field, u32 op, char *rulestr, void **vrule) 3550 { 3551 char **rule = (char **)vrule; 3552 *rule = NULL; 3553 3554 if (field != AUDIT_SUBJ_USER && field != AUDIT_OBJ_USER) 3555 return -EINVAL; 3556 3557 if (op != Audit_equal && op != Audit_not_equal) 3558 return -EINVAL; 3559 3560 *rule = smk_import(rulestr, 0); 3561 3562 return 0; 3563 } 3564 3565 /** 3566 * smack_audit_rule_known - Distinguish Smack audit rules 3567 * @krule: rule of interest, in Audit kernel representation format 3568 * 3569 * This is used to filter Smack rules from remaining Audit ones. 3570 * If it's proved that this rule belongs to us, the 3571 * audit_rule_match hook will be called to do the final judgement. 3572 */ 3573 static int smack_audit_rule_known(struct audit_krule *krule) 3574 { 3575 struct audit_field *f; 3576 int i; 3577 3578 for (i = 0; i < krule->field_count; i++) { 3579 f = &krule->fields[i]; 3580 3581 if (f->type == AUDIT_SUBJ_USER || f->type == AUDIT_OBJ_USER) 3582 return 1; 3583 } 3584 3585 return 0; 3586 } 3587 3588 /** 3589 * smack_audit_rule_match - Audit given object ? 3590 * @secid: security id for identifying the object to test 3591 * @field: audit rule flags given from user-space 3592 * @op: required testing operator 3593 * @vrule: smack internal rule presentation 3594 * @actx: audit context associated with the check 3595 * 3596 * The core Audit hook. It's used to take the decision of 3597 * whether to audit or not to audit a given object. 3598 */ 3599 static int smack_audit_rule_match(u32 secid, u32 field, u32 op, void *vrule, 3600 struct audit_context *actx) 3601 { 3602 struct smack_known *skp; 3603 char *rule = vrule; 3604 3605 if (!rule) { 3606 audit_log(actx, GFP_ATOMIC, AUDIT_SELINUX_ERR, 3607 "Smack: missing rule\n"); 3608 return -ENOENT; 3609 } 3610 3611 if (field != AUDIT_SUBJ_USER && field != AUDIT_OBJ_USER) 3612 return 0; 3613 3614 skp = smack_from_secid(secid); 3615 3616 /* 3617 * No need to do string comparisons. If a match occurs, 3618 * both pointers will point to the same smack_known 3619 * label. 3620 */ 3621 if (op == Audit_equal) 3622 return (rule == skp->smk_known); 3623 if (op == Audit_not_equal) 3624 return (rule != skp->smk_known); 3625 3626 return 0; 3627 } 3628 3629 /** 3630 * smack_audit_rule_free - free smack rule representation 3631 * @vrule: rule to be freed. 3632 * 3633 * No memory was allocated. 3634 */ 3635 static void smack_audit_rule_free(void *vrule) 3636 { 3637 /* No-op */ 3638 } 3639 3640 #endif /* CONFIG_AUDIT */ 3641 3642 /** 3643 * smack_ismaclabel - check if xattr @name references a smack MAC label 3644 * @name: Full xattr name to check. 3645 */ 3646 static int smack_ismaclabel(const char *name) 3647 { 3648 return (strcmp(name, XATTR_SMACK_SUFFIX) == 0); 3649 } 3650 3651 3652 /** 3653 * smack_secid_to_secctx - return the smack label for a secid 3654 * @secid: incoming integer 3655 * @secdata: destination 3656 * @seclen: how long it is 3657 * 3658 * Exists for networking code. 3659 */ 3660 static int smack_secid_to_secctx(u32 secid, char **secdata, u32 *seclen) 3661 { 3662 struct smack_known *skp = smack_from_secid(secid); 3663 3664 if (secdata) 3665 *secdata = skp->smk_known; 3666 *seclen = strlen(skp->smk_known); 3667 return 0; 3668 } 3669 3670 /** 3671 * smack_secctx_to_secid - return the secid for a smack label 3672 * @secdata: smack label 3673 * @seclen: how long result is 3674 * @secid: outgoing integer 3675 * 3676 * Exists for audit and networking code. 3677 */ 3678 static int smack_secctx_to_secid(const char *secdata, u32 seclen, u32 *secid) 3679 { 3680 *secid = smack_to_secid(secdata); 3681 return 0; 3682 } 3683 3684 /** 3685 * smack_release_secctx - don't do anything. 3686 * @secdata: unused 3687 * @seclen: unused 3688 * 3689 * Exists to make sure nothing gets done, and properly 3690 */ 3691 static void smack_release_secctx(char *secdata, u32 seclen) 3692 { 3693 } 3694 3695 static int smack_inode_notifysecctx(struct inode *inode, void *ctx, u32 ctxlen) 3696 { 3697 return smack_inode_setsecurity(inode, XATTR_SMACK_SUFFIX, ctx, ctxlen, 0); 3698 } 3699 3700 static int smack_inode_setsecctx(struct dentry *dentry, void *ctx, u32 ctxlen) 3701 { 3702 return __vfs_setxattr_noperm(dentry, XATTR_NAME_SMACK, ctx, ctxlen, 0); 3703 } 3704 3705 static int smack_inode_getsecctx(struct inode *inode, void **ctx, u32 *ctxlen) 3706 { 3707 int len = 0; 3708 len = smack_inode_getsecurity(inode, XATTR_SMACK_SUFFIX, ctx, true); 3709 3710 if (len < 0) 3711 return len; 3712 *ctxlen = len; 3713 return 0; 3714 } 3715 3716 struct security_operations smack_ops = { 3717 .name = "smack", 3718 3719 .ptrace_access_check = smack_ptrace_access_check, 3720 .ptrace_traceme = smack_ptrace_traceme, 3721 .syslog = smack_syslog, 3722 3723 .sb_alloc_security = smack_sb_alloc_security, 3724 .sb_free_security = smack_sb_free_security, 3725 .sb_copy_data = smack_sb_copy_data, 3726 .sb_kern_mount = smack_sb_kern_mount, 3727 .sb_statfs = smack_sb_statfs, 3728 .sb_mount = smack_sb_mount, 3729 .sb_umount = smack_sb_umount, 3730 3731 .bprm_set_creds = smack_bprm_set_creds, 3732 .bprm_committing_creds = smack_bprm_committing_creds, 3733 .bprm_secureexec = smack_bprm_secureexec, 3734 3735 .inode_alloc_security = smack_inode_alloc_security, 3736 .inode_free_security = smack_inode_free_security, 3737 .inode_init_security = smack_inode_init_security, 3738 .inode_link = smack_inode_link, 3739 .inode_unlink = smack_inode_unlink, 3740 .inode_rmdir = smack_inode_rmdir, 3741 .inode_rename = smack_inode_rename, 3742 .inode_permission = smack_inode_permission, 3743 .inode_setattr = smack_inode_setattr, 3744 .inode_getattr = smack_inode_getattr, 3745 .inode_setxattr = smack_inode_setxattr, 3746 .inode_post_setxattr = smack_inode_post_setxattr, 3747 .inode_getxattr = smack_inode_getxattr, 3748 .inode_removexattr = smack_inode_removexattr, 3749 .inode_getsecurity = smack_inode_getsecurity, 3750 .inode_setsecurity = smack_inode_setsecurity, 3751 .inode_listsecurity = smack_inode_listsecurity, 3752 .inode_getsecid = smack_inode_getsecid, 3753 3754 .file_permission = smack_file_permission, 3755 .file_alloc_security = smack_file_alloc_security, 3756 .file_free_security = smack_file_free_security, 3757 .file_ioctl = smack_file_ioctl, 3758 .file_lock = smack_file_lock, 3759 .file_fcntl = smack_file_fcntl, 3760 .mmap_file = smack_mmap_file, 3761 .mmap_addr = cap_mmap_addr, 3762 .file_set_fowner = smack_file_set_fowner, 3763 .file_send_sigiotask = smack_file_send_sigiotask, 3764 .file_receive = smack_file_receive, 3765 3766 .file_open = smack_file_open, 3767 3768 .cred_alloc_blank = smack_cred_alloc_blank, 3769 .cred_free = smack_cred_free, 3770 .cred_prepare = smack_cred_prepare, 3771 .cred_transfer = smack_cred_transfer, 3772 .kernel_act_as = smack_kernel_act_as, 3773 .kernel_create_files_as = smack_kernel_create_files_as, 3774 .task_setpgid = smack_task_setpgid, 3775 .task_getpgid = smack_task_getpgid, 3776 .task_getsid = smack_task_getsid, 3777 .task_getsecid = smack_task_getsecid, 3778 .task_setnice = smack_task_setnice, 3779 .task_setioprio = smack_task_setioprio, 3780 .task_getioprio = smack_task_getioprio, 3781 .task_setscheduler = smack_task_setscheduler, 3782 .task_getscheduler = smack_task_getscheduler, 3783 .task_movememory = smack_task_movememory, 3784 .task_kill = smack_task_kill, 3785 .task_wait = smack_task_wait, 3786 .task_to_inode = smack_task_to_inode, 3787 3788 .ipc_permission = smack_ipc_permission, 3789 .ipc_getsecid = smack_ipc_getsecid, 3790 3791 .msg_msg_alloc_security = smack_msg_msg_alloc_security, 3792 .msg_msg_free_security = smack_msg_msg_free_security, 3793 3794 .msg_queue_alloc_security = smack_msg_queue_alloc_security, 3795 .msg_queue_free_security = smack_msg_queue_free_security, 3796 .msg_queue_associate = smack_msg_queue_associate, 3797 .msg_queue_msgctl = smack_msg_queue_msgctl, 3798 .msg_queue_msgsnd = smack_msg_queue_msgsnd, 3799 .msg_queue_msgrcv = smack_msg_queue_msgrcv, 3800 3801 .shm_alloc_security = smack_shm_alloc_security, 3802 .shm_free_security = smack_shm_free_security, 3803 .shm_associate = smack_shm_associate, 3804 .shm_shmctl = smack_shm_shmctl, 3805 .shm_shmat = smack_shm_shmat, 3806 3807 .sem_alloc_security = smack_sem_alloc_security, 3808 .sem_free_security = smack_sem_free_security, 3809 .sem_associate = smack_sem_associate, 3810 .sem_semctl = smack_sem_semctl, 3811 .sem_semop = smack_sem_semop, 3812 3813 .d_instantiate = smack_d_instantiate, 3814 3815 .getprocattr = smack_getprocattr, 3816 .setprocattr = smack_setprocattr, 3817 3818 .unix_stream_connect = smack_unix_stream_connect, 3819 .unix_may_send = smack_unix_may_send, 3820 3821 .socket_post_create = smack_socket_post_create, 3822 .socket_bind = smack_socket_bind, 3823 .socket_connect = smack_socket_connect, 3824 .socket_sendmsg = smack_socket_sendmsg, 3825 .socket_sock_rcv_skb = smack_socket_sock_rcv_skb, 3826 .socket_getpeersec_stream = smack_socket_getpeersec_stream, 3827 .socket_getpeersec_dgram = smack_socket_getpeersec_dgram, 3828 .sk_alloc_security = smack_sk_alloc_security, 3829 .sk_free_security = smack_sk_free_security, 3830 .sock_graft = smack_sock_graft, 3831 .inet_conn_request = smack_inet_conn_request, 3832 .inet_csk_clone = smack_inet_csk_clone, 3833 3834 /* key management security hooks */ 3835 #ifdef CONFIG_KEYS 3836 .key_alloc = smack_key_alloc, 3837 .key_free = smack_key_free, 3838 .key_permission = smack_key_permission, 3839 #endif /* CONFIG_KEYS */ 3840 3841 /* Audit hooks */ 3842 #ifdef CONFIG_AUDIT 3843 .audit_rule_init = smack_audit_rule_init, 3844 .audit_rule_known = smack_audit_rule_known, 3845 .audit_rule_match = smack_audit_rule_match, 3846 .audit_rule_free = smack_audit_rule_free, 3847 #endif /* CONFIG_AUDIT */ 3848 3849 .ismaclabel = smack_ismaclabel, 3850 .secid_to_secctx = smack_secid_to_secctx, 3851 .secctx_to_secid = smack_secctx_to_secid, 3852 .release_secctx = smack_release_secctx, 3853 .inode_notifysecctx = smack_inode_notifysecctx, 3854 .inode_setsecctx = smack_inode_setsecctx, 3855 .inode_getsecctx = smack_inode_getsecctx, 3856 }; 3857 3858 3859 static __init void init_smack_known_list(void) 3860 { 3861 /* 3862 * Initialize rule list locks 3863 */ 3864 mutex_init(&smack_known_huh.smk_rules_lock); 3865 mutex_init(&smack_known_hat.smk_rules_lock); 3866 mutex_init(&smack_known_floor.smk_rules_lock); 3867 mutex_init(&smack_known_star.smk_rules_lock); 3868 mutex_init(&smack_known_invalid.smk_rules_lock); 3869 mutex_init(&smack_known_web.smk_rules_lock); 3870 /* 3871 * Initialize rule lists 3872 */ 3873 INIT_LIST_HEAD(&smack_known_huh.smk_rules); 3874 INIT_LIST_HEAD(&smack_known_hat.smk_rules); 3875 INIT_LIST_HEAD(&smack_known_star.smk_rules); 3876 INIT_LIST_HEAD(&smack_known_floor.smk_rules); 3877 INIT_LIST_HEAD(&smack_known_invalid.smk_rules); 3878 INIT_LIST_HEAD(&smack_known_web.smk_rules); 3879 /* 3880 * Create the known labels list 3881 */ 3882 list_add(&smack_known_huh.list, &smack_known_list); 3883 list_add(&smack_known_hat.list, &smack_known_list); 3884 list_add(&smack_known_star.list, &smack_known_list); 3885 list_add(&smack_known_floor.list, &smack_known_list); 3886 list_add(&smack_known_invalid.list, &smack_known_list); 3887 list_add(&smack_known_web.list, &smack_known_list); 3888 } 3889 3890 /** 3891 * smack_init - initialize the smack system 3892 * 3893 * Returns 0 3894 */ 3895 static __init int smack_init(void) 3896 { 3897 struct cred *cred; 3898 struct task_smack *tsp; 3899 3900 if (!security_module_enable(&smack_ops)) 3901 return 0; 3902 3903 tsp = new_task_smack(&smack_known_floor, &smack_known_floor, 3904 GFP_KERNEL); 3905 if (tsp == NULL) 3906 return -ENOMEM; 3907 3908 printk(KERN_INFO "Smack: Initializing.\n"); 3909 3910 /* 3911 * Set the security state for the initial task. 3912 */ 3913 cred = (struct cred *) current->cred; 3914 cred->security = tsp; 3915 3916 /* initialize the smack_known_list */ 3917 init_smack_known_list(); 3918 3919 /* 3920 * Register with LSM 3921 */ 3922 if (register_security(&smack_ops)) 3923 panic("smack: Unable to register with kernel.\n"); 3924 3925 return 0; 3926 } 3927 3928 /* 3929 * Smack requires early initialization in order to label 3930 * all processes and objects when they are created. 3931 */ 3932 security_initcall(smack_init); 3933