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