err.no Git - linux-2.6/blob - security/smack/smack_lsm.c

   1 /*
   2  *  Simplified MAC Kernel (smack) security module
   3  *
   4  *  This file contains the smack hook function implementations.
   5  *
   6  *  Author:
   7  *      Casey Schaufler <casey@schaufler-ca.com>
   8  *
   9  *  Copyright (C) 2007 Casey Schaufler <casey@schaufler-ca.com>
  10  *
  11  *      This program is free software; you can redistribute it and/or modify
  12  *      it under the terms of the GNU General Public License version 2,
  13  *      as published by the Free Software Foundation.
  14  */
  15
  16 #include <linux/xattr.h>
  17 #include <linux/pagemap.h>
  18 #include <linux/mount.h>
  19 #include <linux/stat.h>
  20 #include <linux/ext2_fs.h>
  21 #include <linux/kd.h>
  22 #include <asm/ioctls.h>
  23 #include <linux/tcp.h>
  24 #include <linux/udp.h>
  25 #include <linux/mutex.h>
  26 #include <linux/pipe_fs_i.h>
  27 #include <net/netlabel.h>
  28 #include <net/cipso_ipv4.h>
  29 #include <linux/audit.h>
  30
  31 #include "smack.h"
  32
  33 /*
  34  * I hope these are the hokeyist lines of code in the module. Casey.
  35  */
  36 #define DEVPTS_SUPER_MAGIC      0x1cd1
  37 #define SOCKFS_MAGIC            0x534F434B
  38 #define TMPFS_MAGIC             0x01021994
  39
  40 /**
  41  * smk_fetch - Fetch the smack label from a file.
  42  * @ip: a pointer to the inode
  43  * @dp: a pointer to the dentry
  44  *
  45  * Returns a pointer to the master list entry for the Smack label
  46  * or NULL if there was no label to fetch.
  47  */
  48 static char *smk_fetch(struct inode *ip, struct dentry *dp)
  49 {
  50         int rc;
  51         char in[SMK_LABELLEN];
  52
  53         if (ip->i_op->getxattr == NULL)
  54                 return NULL;
  55
  56         rc = ip->i_op->getxattr(dp, XATTR_NAME_SMACK, in, SMK_LABELLEN);
  57         if (rc < 0)
  58                 return NULL;
  59
  60         return smk_import(in, rc);
  61 }
  62
  63 /**
  64  * new_inode_smack - allocate an inode security blob
  65  * @smack: a pointer to the Smack label to use in the blob
  66  *
  67  * Returns the new blob or NULL if there's no memory available
  68  */
  69 struct inode_smack *new_inode_smack(char *smack)
  70 {
  71         struct inode_smack *isp;
  72
  73         isp = kzalloc(sizeof(struct inode_smack), GFP_KERNEL);
  74         if (isp == NULL)
  75                 return NULL;
  76
  77         isp->smk_inode = smack;
  78         isp->smk_flags = 0;
  79         mutex_init(&isp->smk_lock);
  80
  81         return isp;
  82 }
  83
  84 /*
  85  * LSM hooks.
  86  * We he, that is fun!
  87  */
  88
  89 /**
  90  * smack_ptrace - Smack approval on ptrace
  91  * @ptp: parent task pointer
  92  * @ctp: child task pointer
  93  *
  94  * Returns 0 if access is OK, an error code otherwise
  95  *
  96  * Do the capability checks, and require read and write.
  97  */
  98 static int smack_ptrace(struct task_struct *ptp, struct task_struct *ctp)
  99 {
 100         int rc;
 101
 102         rc = cap_ptrace(ptp, ctp);
 103         if (rc != 0)
 104                 return rc;
 105
 106         rc = smk_access(ptp->security, ctp->security, MAY_READWRITE);
 107         if (rc != 0 && __capable(ptp, CAP_MAC_OVERRIDE))
 108                 return 0;
 109
 110         return rc;
 111 }
 112
 113 /**
 114  * smack_syslog - Smack approval on syslog
 115  * @type: message type
 116  *
 117  * Require that the task has the floor label
 118  *
 119  * Returns 0 on success, error code otherwise.
 120  */
 121 static int smack_syslog(int type)
 122 {
 123         int rc;
 124         char *sp = current->security;
 125
 126         rc = cap_syslog(type);
 127         if (rc != 0)
 128                 return rc;
 129
 130         if (capable(CAP_MAC_OVERRIDE))
 131                 return 0;
 132
 133          if (sp != smack_known_floor.smk_known)
 134                 rc = -EACCES;
 135
 136         return rc;
 137 }
 138
 139
 140 /*
 141  * Superblock Hooks.
 142  */
 143
 144 /**
 145  * smack_sb_alloc_security - allocate a superblock blob
 146  * @sb: the superblock getting the blob
 147  *
 148  * Returns 0 on success or -ENOMEM on error.
 149  */
 150 static int smack_sb_alloc_security(struct super_block *sb)
 151 {
 152         struct superblock_smack *sbsp;
 153
 154         sbsp = kzalloc(sizeof(struct superblock_smack), GFP_KERNEL);
 155
 156         if (sbsp == NULL)
 157                 return -ENOMEM;
 158
 159         sbsp->smk_root = smack_known_floor.smk_known;
 160         sbsp->smk_default = smack_known_floor.smk_known;
 161         sbsp->smk_floor = smack_known_floor.smk_known;
 162         sbsp->smk_hat = smack_known_hat.smk_known;
 163         sbsp->smk_initialized = 0;
 164         spin_lock_init(&sbsp->smk_sblock);
 165
 166         sb->s_security = sbsp;
 167
 168         return 0;
 169 }
 170
 171 /**
 172  * smack_sb_free_security - free a superblock blob
 173  * @sb: the superblock getting the blob
 174  *
 175  */
 176 static void smack_sb_free_security(struct super_block *sb)
 177 {
 178         kfree(sb->s_security);
 179         sb->s_security = NULL;
 180 }
 181
 182 /**
 183  * smack_sb_copy_data - copy mount options data for processing
 184  * @type: file system type
 185  * @orig: where to start
 186  * @smackopts
 187  *
 188  * Returns 0 on success or -ENOMEM on error.
 189  *
 190  * Copy the Smack specific mount options out of the mount
 191  * options list.
 192  */
 193 static int smack_sb_copy_data(char *orig, char *smackopts)
 194 {
 195         char *cp, *commap, *otheropts, *dp;
 196
 197         otheropts = (char *)get_zeroed_page(GFP_KERNEL);
 198         if (otheropts == NULL)
 199                 return -ENOMEM;
 200
 201         for (cp = orig, commap = orig; commap != NULL; cp = commap + 1) {
 202                 if (strstr(cp, SMK_FSDEFAULT) == cp)
 203                         dp = smackopts;
 204                 else if (strstr(cp, SMK_FSFLOOR) == cp)
 205                         dp = smackopts;
 206                 else if (strstr(cp, SMK_FSHAT) == cp)
 207                         dp = smackopts;
 208                 else if (strstr(cp, SMK_FSROOT) == cp)
 209                         dp = smackopts;
 210                 else
 211                         dp = otheropts;
 212
 213                 commap = strchr(cp, ',');
 214                 if (commap != NULL)
 215                         *commap = '\0';
 216
 217                 if (*dp != '\0')
 218                         strcat(dp, ",");
 219                 strcat(dp, cp);
 220         }
 221
 222         strcpy(orig, otheropts);
 223         free_page((unsigned long)otheropts);
 224
 225         return 0;
 226 }
 227
 228 /**
 229  * smack_sb_kern_mount - Smack specific mount processing
 230  * @sb: the file system superblock
 231  * @data: the smack mount options
 232  *
 233  * Returns 0 on success, an error code on failure
 234  */
 235 static int smack_sb_kern_mount(struct super_block *sb, void *data)
 236 {
 237         struct dentry *root = sb->s_root;
 238         struct inode *inode = root->d_inode;
 239         struct superblock_smack *sp = sb->s_security;
 240         struct inode_smack *isp;
 241         char *op;
 242         char *commap;
 243         char *nsp;
 244
 245         spin_lock(&sp->smk_sblock);
 246         if (sp->smk_initialized != 0) {
 247                 spin_unlock(&sp->smk_sblock);
 248                 return 0;
 249         }
 250         sp->smk_initialized = 1;
 251         spin_unlock(&sp->smk_sblock);
 252
 253         for (op = data; op != NULL; op = commap) {
 254                 commap = strchr(op, ',');
 255                 if (commap != NULL)
 256                         *commap++ = '\0';
 257
 258                 if (strncmp(op, SMK_FSHAT, strlen(SMK_FSHAT)) == 0) {
 259                         op += strlen(SMK_FSHAT);
 260                         nsp = smk_import(op, 0);
 261                         if (nsp != NULL)
 262                                 sp->smk_hat = nsp;
 263                 } else if (strncmp(op, SMK_FSFLOOR, strlen(SMK_FSFLOOR)) == 0) {
 264                         op += strlen(SMK_FSFLOOR);
 265                         nsp = smk_import(op, 0);
 266                         if (nsp != NULL)
 267                                 sp->smk_floor = nsp;
 268                 } else if (strncmp(op, SMK_FSDEFAULT,
 269                                    strlen(SMK_FSDEFAULT)) == 0) {
 270                         op += strlen(SMK_FSDEFAULT);
 271                         nsp = smk_import(op, 0);
 272                         if (nsp != NULL)
 273                                 sp->smk_default = nsp;
 274                 } else if (strncmp(op, SMK_FSROOT, strlen(SMK_FSROOT)) == 0) {
 275                         op += strlen(SMK_FSROOT);
 276                         nsp = smk_import(op, 0);
 277                         if (nsp != NULL)
 278                                 sp->smk_root = nsp;
 279                 }
 280         }
 281
 282         /*
 283          * Initialize the root inode.
 284          */
 285         isp = inode->i_security;
 286         if (isp == NULL)
 287                 inode->i_security = new_inode_smack(sp->smk_root);
 288         else
 289                 isp->smk_inode = sp->smk_root;
 290
 291         return 0;
 292 }
 293
 294 /**
 295  * smack_sb_statfs - Smack check on statfs
 296  * @dentry: identifies the file system in question
 297  *
 298  * Returns 0 if current can read the floor of the filesystem,
 299  * and error code otherwise
 300  */
 301 static int smack_sb_statfs(struct dentry *dentry)
 302 {
 303         struct superblock_smack *sbp = dentry->d_sb->s_security;
 304
 305         return smk_curacc(sbp->smk_floor, MAY_READ);
 306 }
 307
 308 /**
 309  * smack_sb_mount - Smack check for mounting
 310  * @dev_name: unused
 311  * @nd: mount point
 312  * @type: unused
 313  * @flags: unused
 314  * @data: unused
 315  *
 316  * Returns 0 if current can write the floor of the filesystem
 317  * being mounted on, an error code otherwise.
 318  */
 319 static int smack_sb_mount(char *dev_name, struct path *path,
 320                           char *type, unsigned long flags, void *data)
 321 {
 322         struct superblock_smack *sbp = path->mnt->mnt_sb->s_security;
 323
 324         return smk_curacc(sbp->smk_floor, MAY_WRITE);
 325 }
 326
 327 /**
 328  * smack_sb_umount - Smack check for unmounting
 329  * @mnt: file system to unmount
 330  * @flags: unused
 331  *
 332  * Returns 0 if current can write the floor of the filesystem
 333  * being unmounted, an error code otherwise.
 334  */
 335 static int smack_sb_umount(struct vfsmount *mnt, int flags)
 336 {
 337         struct superblock_smack *sbp;
 338
 339         sbp = mnt->mnt_sb->s_security;
 340
 341         return smk_curacc(sbp->smk_floor, MAY_WRITE);
 342 }
 343
 344 /*
 345  * Inode hooks
 346  */
 347
 348 /**
 349  * smack_inode_alloc_security - allocate an inode blob
 350  * @inode - the inode in need of a blob
 351  *
 352  * Returns 0 if it gets a blob, -ENOMEM otherwise
 353  */
 354 static int smack_inode_alloc_security(struct inode *inode)
 355 {
 356         inode->i_security = new_inode_smack(current->security);
 357         if (inode->i_security == NULL)
 358                 return -ENOMEM;
 359         return 0;
 360 }
 361
 362 /**
 363  * smack_inode_free_security - free an inode blob
 364  * @inode - the inode with a blob
 365  *
 366  * Clears the blob pointer in inode
 367  */
 368 static void smack_inode_free_security(struct inode *inode)
 369 {
 370         kfree(inode->i_security);
 371         inode->i_security = NULL;
 372 }
 373
 374 /**
 375  * smack_inode_init_security - copy out the smack from an inode
 376  * @inode: the inode
 377  * @dir: unused
 378  * @name: where to put the attribute name
 379  * @value: where to put the attribute value
 380  * @len: where to put the length of the attribute
 381  *
 382  * Returns 0 if it all works out, -ENOMEM if there's no memory
 383  */
 384 static int smack_inode_init_security(struct inode *inode, struct inode *dir,
 385                                      char **name, void **value, size_t *len)
 386 {
 387         char *isp = smk_of_inode(inode);
 388
 389         if (name) {
 390                 *name = kstrdup(XATTR_SMACK_SUFFIX, GFP_KERNEL);
 391                 if (*name == NULL)
 392                         return -ENOMEM;
 393         }
 394
 395         if (value) {
 396                 *value = kstrdup(isp, GFP_KERNEL);
 397                 if (*value == NULL)
 398                         return -ENOMEM;
 399         }
 400
 401         if (len)
 402                 *len = strlen(isp) + 1;
 403
 404         return 0;
 405 }
 406
 407 /**
 408  * smack_inode_link - Smack check on link
 409  * @old_dentry: the existing object
 410  * @dir: unused
 411  * @new_dentry: the new object
 412  *
 413  * Returns 0 if access is permitted, an error code otherwise
 414  */
 415 static int smack_inode_link(struct dentry *old_dentry, struct inode *dir,
 416                             struct dentry *new_dentry)
 417 {
 418         int rc;
 419         char *isp;
 420
 421         isp = smk_of_inode(old_dentry->d_inode);
 422         rc = smk_curacc(isp, MAY_WRITE);
 423
 424         if (rc == 0 && new_dentry->d_inode != NULL) {
 425                 isp = smk_of_inode(new_dentry->d_inode);
 426                 rc = smk_curacc(isp, MAY_WRITE);
 427         }
 428
 429         return rc;
 430 }
 431
 432 /**
 433  * smack_inode_unlink - Smack check on inode deletion
 434  * @dir: containing directory object
 435  * @dentry: file to unlink
 436  *
 437  * Returns 0 if current can write the containing directory
 438  * and the object, error code otherwise
 439  */
 440 static int smack_inode_unlink(struct inode *dir, struct dentry *dentry)
 441 {
 442         struct inode *ip = dentry->d_inode;
 443         int rc;
 444
 445         /*
 446          * You need write access to the thing you're unlinking
 447          */
 448         rc = smk_curacc(smk_of_inode(ip), MAY_WRITE);
 449         if (rc == 0)
 450                 /*
 451                  * You also need write access to the containing directory
 452                  */
 453                 rc = smk_curacc(smk_of_inode(dir), MAY_WRITE);
 454
 455         return rc;
 456 }
 457
 458 /**
 459  * smack_inode_rmdir - Smack check on directory deletion
 460  * @dir: containing directory object
 461  * @dentry: directory to unlink
 462  *
 463  * Returns 0 if current can write the containing directory
 464  * and the directory, error code otherwise
 465  */
 466 static int smack_inode_rmdir(struct inode *dir, struct dentry *dentry)
 467 {
 468         int rc;
 469
 470         /*
 471          * You need write access to the thing you're removing
 472          */
 473         rc = smk_curacc(smk_of_inode(dentry->d_inode), MAY_WRITE);
 474         if (rc == 0)
 475                 /*
 476                  * You also need write access to the containing directory
 477                  */
 478                 rc = smk_curacc(smk_of_inode(dir), MAY_WRITE);
 479
 480         return rc;
 481 }
 482
 483 /**
 484  * smack_inode_rename - Smack check on rename
 485  * @old_inode: the old directory
 486  * @old_dentry: unused
 487  * @new_inode: the new directory
 488  * @new_dentry: unused
 489  *
 490  * Read and write access is required on both the old and
 491  * new directories.
 492  *
 493  * Returns 0 if access is permitted, an error code otherwise
 494  */
 495 static int smack_inode_rename(struct inode *old_inode,
 496                               struct dentry *old_dentry,
 497                               struct inode *new_inode,
 498                               struct dentry *new_dentry)
 499 {
 500         int rc;
 501         char *isp;
 502
 503         isp = smk_of_inode(old_dentry->d_inode);
 504         rc = smk_curacc(isp, MAY_READWRITE);
 505
 506         if (rc == 0 && new_dentry->d_inode != NULL) {
 507                 isp = smk_of_inode(new_dentry->d_inode);
 508                 rc = smk_curacc(isp, MAY_READWRITE);
 509         }
 510
 511         return rc;
 512 }
 513
 514 /**
 515  * smack_inode_permission - Smack version of permission()
 516  * @inode: the inode in question
 517  * @mask: the access requested
 518  * @nd: unused
 519  *
 520  * This is the important Smack hook.
 521  *
 522  * Returns 0 if access is permitted, -EACCES otherwise
 523  */
 524 static int smack_inode_permission(struct inode *inode, int mask,
 525                                   struct nameidata *nd)
 526 {
 527         /*
 528          * No permission to check. Existence test. Yup, it's there.
 529          */
 530         if (mask == 0)
 531                 return 0;
 532
 533         return smk_curacc(smk_of_inode(inode), mask);
 534 }
 535
 536 /**
 537  * smack_inode_setattr - Smack check for setting attributes
 538  * @dentry: the object
 539  * @iattr: for the force flag
 540  *
 541  * Returns 0 if access is permitted, an error code otherwise
 542  */
 543 static int smack_inode_setattr(struct dentry *dentry, struct iattr *iattr)
 544 {
 545         /*
 546          * Need to allow for clearing the setuid bit.
 547          */
 548         if (iattr->ia_valid & ATTR_FORCE)
 549                 return 0;
 550
 551         return smk_curacc(smk_of_inode(dentry->d_inode), MAY_WRITE);
 552 }
 553
 554 /**
 555  * smack_inode_getattr - Smack check for getting attributes
 556  * @mnt: unused
 557  * @dentry: the object
 558  *
 559  * Returns 0 if access is permitted, an error code otherwise
 560  */
 561 static int smack_inode_getattr(struct vfsmount *mnt, struct dentry *dentry)
 562 {
 563         return smk_curacc(smk_of_inode(dentry->d_inode), MAY_READ);
 564 }
 565
 566 /**
 567  * smack_inode_setxattr - Smack check for setting xattrs
 568  * @dentry: the object
 569  * @name: name of the attribute
 570  * @value: unused
 571  * @size: unused
 572  * @flags: unused
 573  *
 574  * This protects the Smack attribute explicitly.
 575  *
 576  * Returns 0 if access is permitted, an error code otherwise
 577  */
 578 static int smack_inode_setxattr(struct dentry *dentry, const char *name,
 579                                 const void *value, size_t size, int flags)
 580 {
 581         int rc = 0;
 582
 583         if (strcmp(name, XATTR_NAME_SMACK) == 0 ||
 584             strcmp(name, XATTR_NAME_SMACKIPIN) == 0 ||
 585             strcmp(name, XATTR_NAME_SMACKIPOUT) == 0) {
 586                 if (!capable(CAP_MAC_ADMIN))
 587                         rc = -EPERM;
 588         } else
 589                 rc = cap_inode_setxattr(dentry, name, value, size, flags);
 590
 591         if (rc == 0)
 592                 rc = smk_curacc(smk_of_inode(dentry->d_inode), MAY_WRITE);
 593
 594         return rc;
 595 }
 596
 597 /**
 598  * smack_inode_post_setxattr - Apply the Smack update approved above
 599  * @dentry: object
 600  * @name: attribute name
 601  * @value: attribute value
 602  * @size: attribute size
 603  * @flags: unused
 604  *
 605  * Set the pointer in the inode blob to the entry found
 606  * in the master label list.
 607  */
 608 static void smack_inode_post_setxattr(struct dentry *dentry, const char *name,
 609                                       const void *value, size_t size, int flags)
 610 {
 611         struct inode_smack *isp;
 612         char *nsp;
 613
 614         /*
 615          * Not SMACK
 616          */
 617         if (strcmp(name, XATTR_NAME_SMACK))
 618                 return;
 619
 620         if (size >= SMK_LABELLEN)
 621                 return;
 622
 623         isp = dentry->d_inode->i_security;
 624
 625         /*
 626          * No locking is done here. This is a pointer
 627          * assignment.
 628          */
 629         nsp = smk_import(value, size);
 630         if (nsp != NULL)
 631                 isp->smk_inode = nsp;
 632         else
 633                 isp->smk_inode = smack_known_invalid.smk_known;
 634
 635         return;
 636 }
 637
 638 /*
 639  * smack_inode_getxattr - Smack check on getxattr
 640  * @dentry: the object
 641  * @name: unused
 642  *
 643  * Returns 0 if access is permitted, an error code otherwise
 644  */
 645 static int smack_inode_getxattr(struct dentry *dentry, const char *name)
 646 {
 647         return smk_curacc(smk_of_inode(dentry->d_inode), MAY_READ);
 648 }
 649
 650 /*
 651  * smack_inode_removexattr - Smack check on removexattr
 652  * @dentry: the object
 653  * @name: name of the attribute
 654  *
 655  * Removing the Smack attribute requires CAP_MAC_ADMIN
 656  *
 657  * Returns 0 if access is permitted, an error code otherwise
 658  */
 659 static int smack_inode_removexattr(struct dentry *dentry, const char *name)
 660 {
 661         int rc = 0;
 662
 663         if (strcmp(name, XATTR_NAME_SMACK) == 0 ||
 664             strcmp(name, XATTR_NAME_SMACKIPIN) == 0 ||
 665             strcmp(name, XATTR_NAME_SMACKIPOUT) == 0) {
 666                 if (!capable(CAP_MAC_ADMIN))
 667                         rc = -EPERM;
 668         } else
 669                 rc = cap_inode_removexattr(dentry, name);
 670
 671         if (rc == 0)
 672                 rc = smk_curacc(smk_of_inode(dentry->d_inode), MAY_WRITE);
 673
 674         return rc;
 675 }
 676
 677 /**
 678  * smack_inode_getsecurity - get smack xattrs
 679  * @inode: the object
 680  * @name: attribute name
 681  * @buffer: where to put the result
 682  * @size: size of the buffer
 683  * @err: unused
 684  *
 685  * Returns the size of the attribute or an error code
 686  */
 687 static int smack_inode_getsecurity(const struct inode *inode,
 688                                    const char *name, void **buffer,
 689                                    bool alloc)
 690 {
 691         struct socket_smack *ssp;
 692         struct socket *sock;
 693         struct super_block *sbp;
 694         struct inode *ip = (struct inode *)inode;
 695         char *isp;
 696         int ilen;
 697         int rc = 0;
 698
 699         if (strcmp(name, XATTR_SMACK_SUFFIX) == 0) {
 700                 isp = smk_of_inode(inode);
 701                 ilen = strlen(isp) + 1;
 702                 *buffer = isp;
 703                 return ilen;
 704         }
 705
 706         /*
 707          * The rest of the Smack xattrs are only on sockets.
 708          */
 709         sbp = ip->i_sb;
 710         if (sbp->s_magic != SOCKFS_MAGIC)
 711                 return -EOPNOTSUPP;
 712
 713         sock = SOCKET_I(ip);
 714         if (sock == NULL || sock->sk == NULL)
 715                 return -EOPNOTSUPP;
 716
 717         ssp = sock->sk->sk_security;
 718
 719         if (strcmp(name, XATTR_SMACK_IPIN) == 0)
 720                 isp = ssp->smk_in;
 721         else if (strcmp(name, XATTR_SMACK_IPOUT) == 0)
 722                 isp = ssp->smk_out;
 723         else
 724                 return -EOPNOTSUPP;
 725
 726         ilen = strlen(isp) + 1;
 727         if (rc == 0) {
 728                 *buffer = isp;
 729                 rc = ilen;
 730         }
 731
 732         return rc;
 733 }
 734
 735
 736 /**
 737  * smack_inode_listsecurity - list the Smack attributes
 738  * @inode: the object
 739  * @buffer: where they go
 740  * @buffer_size: size of buffer
 741  *
 742  * Returns 0 on success, -EINVAL otherwise
 743  */
 744 static int smack_inode_listsecurity(struct inode *inode, char *buffer,
 745                                     size_t buffer_size)
 746 {
 747         int len = strlen(XATTR_NAME_SMACK);
 748
 749         if (buffer != NULL && len <= buffer_size) {
 750                 memcpy(buffer, XATTR_NAME_SMACK, len);
 751                 return len;
 752         }
 753         return -EINVAL;
 754 }
 755
 756 /**
 757  * smack_inode_getsecid - Extract inode's security id
 758  * @inode: inode to extract the info from
 759  * @secid: where result will be saved
 760  */
 761 static void smack_inode_getsecid(const struct inode *inode, u32 *secid)
 762 {
 763         struct inode_smack *isp = inode->i_security;
 764
 765         *secid = smack_to_secid(isp->smk_inode);
 766 }
 767
 768 /*
 769  * File Hooks
 770  */
 771
 772 /**
 773  * smack_file_permission - Smack check on file operations
 774  * @file: unused
 775  * @mask: unused
 776  *
 777  * Returns 0
 778  *
 779  * Should access checks be done on each read or write?
 780  * UNICOS and SELinux say yes.
 781  * Trusted Solaris, Trusted Irix, and just about everyone else says no.
 782  *
 783  * I'll say no for now. Smack does not do the frequent
 784  * label changing that SELinux does.
 785  */
 786 static int smack_file_permission(struct file *file, int mask)
 787 {
 788         return 0;
 789 }
 790
 791 /**
 792  * smack_file_alloc_security - assign a file security blob
 793  * @file: the object
 794  *
 795  * The security blob for a file is a pointer to the master
 796  * label list, so no allocation is done.
 797  *
 798  * Returns 0
 799  */
 800 static int smack_file_alloc_security(struct file *file)
 801 {
 802         file->f_security = current->security;
 803         return 0;
 804 }
 805
 806 /**
 807  * smack_file_free_security - clear a file security blob
 808  * @file: the object
 809  *
 810  * The security blob for a file is a pointer to the master
 811  * label list, so no memory is freed.
 812  */
 813 static void smack_file_free_security(struct file *file)
 814 {
 815         file->f_security = NULL;
 816 }
 817
 818 /**
 819  * smack_file_ioctl - Smack check on ioctls
 820  * @file: the object
 821  * @cmd: what to do
 822  * @arg: unused
 823  *
 824  * Relies heavily on the correct use of the ioctl command conventions.
 825  *
 826  * Returns 0 if allowed, error code otherwise
 827  */
 828 static int smack_file_ioctl(struct file *file, unsigned int cmd,
 829                             unsigned long arg)
 830 {
 831         int rc = 0;
 832
 833         if (_IOC_DIR(cmd) & _IOC_WRITE)
 834                 rc = smk_curacc(file->f_security, MAY_WRITE);
 835
 836         if (rc == 0 && (_IOC_DIR(cmd) & _IOC_READ))
 837                 rc = smk_curacc(file->f_security, MAY_READ);
 838
 839         return rc;
 840 }
 841
 842 /**
 843  * smack_file_lock - Smack check on file locking
 844  * @file: the object
 845  * @cmd unused
 846  *
 847  * Returns 0 if current has write access, error code otherwise
 848  */
 849 static int smack_file_lock(struct file *file, unsigned int cmd)
 850 {
 851         return smk_curacc(file->f_security, MAY_WRITE);
 852 }
 853
 854 /**
 855  * smack_file_fcntl - Smack check on fcntl
 856  * @file: the object
 857  * @cmd: what action to check
 858  * @arg: unused
 859  *
 860  * Returns 0 if current has access, error code otherwise
 861  */
 862 static int smack_file_fcntl(struct file *file, unsigned int cmd,
 863                             unsigned long arg)
 864 {
 865         int rc;
 866
 867         switch (cmd) {
 868         case F_DUPFD:
 869         case F_GETFD:
 870         case F_GETFL:
 871         case F_GETLK:
 872         case F_GETOWN:
 873         case F_GETSIG:
 874                 rc = smk_curacc(file->f_security, MAY_READ);
 875                 break;
 876         case F_SETFD:
 877         case F_SETFL:
 878         case F_SETLK:
 879         case F_SETLKW:
 880         case F_SETOWN:
 881         case F_SETSIG:
 882                 rc = smk_curacc(file->f_security, MAY_WRITE);
 883                 break;
 884         default:
 885                 rc = smk_curacc(file->f_security, MAY_READWRITE);
 886         }
 887
 888         return rc;
 889 }
 890
 891 /**
 892  * smack_file_set_fowner - set the file security blob value
 893  * @file: object in question
 894  *
 895  * Returns 0
 896  * Further research may be required on this one.
 897  */
 898 static int smack_file_set_fowner(struct file *file)
 899 {
 900         file->f_security = current->security;
 901         return 0;
 902 }
 903
 904 /**
 905  * smack_file_send_sigiotask - Smack on sigio
 906  * @tsk: The target task
 907  * @fown: the object the signal come from
 908  * @signum: unused
 909  *
 910  * Allow a privileged task to get signals even if it shouldn't
 911  *
 912  * Returns 0 if a subject with the object's smack could
 913  * write to the task, an error code otherwise.
 914  */
 915 static int smack_file_send_sigiotask(struct task_struct *tsk,
 916                                      struct fown_struct *fown, int signum)
 917 {
 918         struct file *file;
 919         int rc;
 920
 921         /*
 922          * struct fown_struct is never outside the context of a struct file
 923          */
 924         file = container_of(fown, struct file, f_owner);
 925         rc = smk_access(file->f_security, tsk->security, MAY_WRITE);
 926         if (rc != 0 && __capable(tsk, CAP_MAC_OVERRIDE))
 927                 return 0;
 928         return rc;
 929 }
 930
 931 /**
 932  * smack_file_receive - Smack file receive check
 933  * @file: the object
 934  *
 935  * Returns 0 if current has access, error code otherwise
 936  */
 937 static int smack_file_receive(struct file *file)
 938 {
 939         int may = 0;
 940
 941         /*
 942          * This code relies on bitmasks.
 943          */
 944         if (file->f_mode & FMODE_READ)
 945                 may = MAY_READ;
 946         if (file->f_mode & FMODE_WRITE)
 947                 may |= MAY_WRITE;
 948
 949         return smk_curacc(file->f_security, may);
 950 }
 951
 952 /*
 953  * Task hooks
 954  */
 955
 956 /**
 957  * smack_task_alloc_security - "allocate" a task blob
 958  * @tsk: the task in need of a blob
 959  *
 960  * Smack isn't using copies of blobs. Everyone
 961  * points to an immutable list. No alloc required.
 962  * No data copy required.
 963  *
 964  * Always returns 0
 965  */
 966 static int smack_task_alloc_security(struct task_struct *tsk)
 967 {
 968         tsk->security = current->security;
 969
 970         return 0;
 971 }
 972
 973 /**
 974  * smack_task_free_security - "free" a task blob
 975  * @task: the task with the blob
 976  *
 977  * Smack isn't using copies of blobs. Everyone
 978  * points to an immutable list. The blobs never go away.
 979  * There is no leak here.
 980  */
 981 static void smack_task_free_security(struct task_struct *task)
 982 {
 983         task->security = NULL;
 984 }
 985
 986 /**
 987  * smack_task_setpgid - Smack check on setting pgid
 988  * @p: the task object
 989  * @pgid: unused
 990  *
 991  * Return 0 if write access is permitted
 992  */
 993 static int smack_task_setpgid(struct task_struct *p, pid_t pgid)
 994 {
 995         return smk_curacc(p->security, MAY_WRITE);
 996 }
 997
 998 /**
 999  * smack_task_getpgid - Smack access check for getpgid
1000  * @p: the object task
1001  *
1002  * Returns 0 if current can read the object task, error code otherwise
1003  */
1004 static int smack_task_getpgid(struct task_struct *p)
1005 {
1006         return smk_curacc(p->security, MAY_READ);
1007 }
1008
1009 /**
1010  * smack_task_getsid - Smack access check for getsid
1011  * @p: the object task
1012  *
1013  * Returns 0 if current can read the object task, error code otherwise
1014  */
1015 static int smack_task_getsid(struct task_struct *p)
1016 {
1017         return smk_curacc(p->security, MAY_READ);
1018 }
1019
1020 /**
1021  * smack_task_getsecid - get the secid of the task
1022  * @p: the object task
1023  * @secid: where to put the result
1024  *
1025  * Sets the secid to contain a u32 version of the smack label.
1026  */
1027 static void smack_task_getsecid(struct task_struct *p, u32 *secid)
1028 {
1029         *secid = smack_to_secid(p->security);
1030 }
1031
1032 /**
1033  * smack_task_setnice - Smack check on setting nice
1034  * @p: the task object
1035  * @nice: unused
1036  *
1037  * Return 0 if write access is permitted
1038  */
1039 static int smack_task_setnice(struct task_struct *p, int nice)
1040 {
1041         int rc;
1042
1043         rc = cap_task_setnice(p, nice);
1044         if (rc == 0)
1045                 rc = smk_curacc(p->security, MAY_WRITE);
1046         return rc;
1047 }
1048
1049 /**
1050  * smack_task_setioprio - Smack check on setting ioprio
1051  * @p: the task object
1052  * @ioprio: unused
1053  *
1054  * Return 0 if write access is permitted
1055  */
1056 static int smack_task_setioprio(struct task_struct *p, int ioprio)
1057 {
1058         int rc;
1059
1060         rc = cap_task_setioprio(p, ioprio);
1061         if (rc == 0)
1062                 rc = smk_curacc(p->security, MAY_WRITE);
1063         return rc;
1064 }
1065
1066 /**
1067  * smack_task_getioprio - Smack check on reading ioprio
1068  * @p: the task object
1069  *
1070  * Return 0 if read access is permitted
1071  */
1072 static int smack_task_getioprio(struct task_struct *p)
1073 {
1074         return smk_curacc(p->security, MAY_READ);
1075 }
1076
1077 /**
1078  * smack_task_setscheduler - Smack check on setting scheduler
1079  * @p: the task object
1080  * @policy: unused
1081  * @lp: unused
1082  *
1083  * Return 0 if read access is permitted
1084  */
1085 static int smack_task_setscheduler(struct task_struct *p, int policy,
1086                                    struct sched_param *lp)
1087 {
1088         int rc;
1089
1090         rc = cap_task_setscheduler(p, policy, lp);
1091         if (rc == 0)
1092                 rc = smk_curacc(p->security, MAY_WRITE);
1093         return rc;
1094 }
1095
1096 /**
1097  * smack_task_getscheduler - Smack check on reading scheduler
1098  * @p: the task object
1099  *
1100  * Return 0 if read access is permitted
1101  */
1102 static int smack_task_getscheduler(struct task_struct *p)
1103 {
1104         return smk_curacc(p->security, MAY_READ);
1105 }
1106
1107 /**
1108  * smack_task_movememory - Smack check on moving memory
1109  * @p: the task object
1110  *
1111  * Return 0 if write access is permitted
1112  */
1113 static int smack_task_movememory(struct task_struct *p)
1114 {
1115         return smk_curacc(p->security, MAY_WRITE);
1116 }
1117
1118 /**
1119  * smack_task_kill - Smack check on signal delivery
1120  * @p: the task object
1121  * @info: unused
1122  * @sig: unused
1123  * @secid: identifies the smack to use in lieu of current's
1124  *
1125  * Return 0 if write access is permitted
1126  *
1127  * The secid behavior is an artifact of an SELinux hack
1128  * in the USB code. Someday it may go away.
1129  */
1130 static int smack_task_kill(struct task_struct *p, struct siginfo *info,
1131                            int sig, u32 secid)
1132 {
1133         /*
1134          * Sending a signal requires that the sender
1135          * can write the receiver.
1136          */
1137         if (secid == 0)
1138                 return smk_curacc(p->security, MAY_WRITE);
1139         /*
1140          * If the secid isn't 0 we're dealing with some USB IO
1141          * specific behavior. This is not clean. For one thing
1142          * we can't take privilege into account.
1143          */
1144         return smk_access(smack_from_secid(secid), p->security, MAY_WRITE);
1145 }
1146
1147 /**
1148  * smack_task_wait - Smack access check for waiting
1149  * @p: task to wait for
1150  *
1151  * Returns 0 if current can wait for p, error code otherwise
1152  */
1153 static int smack_task_wait(struct task_struct *p)
1154 {
1155         int rc;
1156
1157         rc = smk_access(current->security, p->security, MAY_WRITE);
1158         if (rc == 0)
1159                 return 0;
1160
1161         /*
1162          * Allow the operation to succeed if either task
1163          * has privilege to perform operations that might
1164          * account for the smack labels having gotten to
1165          * be different in the first place.
1166          *
1167          * This breaks the strict subjet/object access
1168          * control ideal, taking the object's privilege
1169          * state into account in the decision as well as
1170          * the smack value.
1171          */
1172         if (capable(CAP_MAC_OVERRIDE) || __capable(p, CAP_MAC_OVERRIDE))
1173                 return 0;
1174
1175         return rc;
1176 }
1177
1178 /**
1179  * smack_task_to_inode - copy task smack into the inode blob
1180  * @p: task to copy from
1181  * inode: inode to copy to
1182  *
1183  * Sets the smack pointer in the inode security blob
1184  */
1185 static void smack_task_to_inode(struct task_struct *p, struct inode *inode)
1186 {
1187         struct inode_smack *isp = inode->i_security;
1188         isp->smk_inode = p->security;
1189 }
1190
1191 /*
1192  * Socket hooks.
1193  */
1194
1195 /**
1196  * smack_sk_alloc_security - Allocate a socket blob
1197  * @sk: the socket
1198  * @family: unused
1199  * @priority: memory allocation priority
1200  *
1201  * Assign Smack pointers to current
1202  *
1203  * Returns 0 on success, -ENOMEM is there's no memory
1204  */
1205 static int smack_sk_alloc_security(struct sock *sk, int family, gfp_t gfp_flags)
1206 {
1207         char *csp = current->security;
1208         struct socket_smack *ssp;
1209
1210         ssp = kzalloc(sizeof(struct socket_smack), gfp_flags);
1211         if (ssp == NULL)
1212                 return -ENOMEM;
1213
1214         ssp->smk_in = csp;
1215         ssp->smk_out = csp;
1216         ssp->smk_packet[0] = '\0';
1217
1218         sk->sk_security = ssp;
1219
1220         return 0;
1221 }
1222
1223 /**
1224  * smack_sk_free_security - Free a socket blob
1225  * @sk: the socket
1226  *
1227  * Clears the blob pointer
1228  */
1229 static void smack_sk_free_security(struct sock *sk)
1230 {
1231         kfree(sk->sk_security);
1232 }
1233
1234 /**
1235  * smack_set_catset - convert a capset to netlabel mls categories
1236  * @catset: the Smack categories
1237  * @sap: where to put the netlabel categories
1238  *
1239  * Allocates and fills attr.mls.cat
1240  */
1241 static void smack_set_catset(char *catset, struct netlbl_lsm_secattr *sap)
1242 {
1243         unsigned char *cp;
1244         unsigned char m;
1245         int cat;
1246         int rc;
1247         int byte;
1248
1249         if (!catset)
1250                 return;
1251
1252         sap->flags |= NETLBL_SECATTR_MLS_CAT;
1253         sap->attr.mls.cat = netlbl_secattr_catmap_alloc(GFP_ATOMIC);
1254         sap->attr.mls.cat->startbit = 0;
1255
1256         for (cat = 1, cp = catset, byte = 0; byte < SMK_LABELLEN; cp++, byte++)
1257                 for (m = 0x80; m != 0; m >>= 1, cat++) {
1258                         if ((m & *cp) == 0)
1259                                 continue;
1260                         rc = netlbl_secattr_catmap_setbit(sap->attr.mls.cat,
1261                                                           cat, GFP_ATOMIC);
1262                 }
1263 }
1264
1265 /**
1266  * smack_to_secattr - fill a secattr from a smack value
1267  * @smack: the smack value
1268  * @nlsp: where the result goes
1269  *
1270  * Casey says that CIPSO is good enough for now.
1271  * It can be used to effect.
1272  * It can also be abused to effect when necessary.
1273  * Appologies to the TSIG group in general and GW in particular.
1274  */
1275 static void smack_to_secattr(char *smack, struct netlbl_lsm_secattr *nlsp)
1276 {
1277         struct smack_cipso cipso;
1278         int rc;
1279
1280         switch (smack_net_nltype) {
1281         case NETLBL_NLTYPE_CIPSOV4:
1282                 nlsp->domain = smack;
1283                 nlsp->flags = NETLBL_SECATTR_DOMAIN | NETLBL_SECATTR_MLS_LVL;
1284
1285                 rc = smack_to_cipso(smack, &cipso);
1286                 if (rc == 0) {
1287                         nlsp->attr.mls.lvl = cipso.smk_level;
1288                         smack_set_catset(cipso.smk_catset, nlsp);
1289                 } else {
1290                         nlsp->attr.mls.lvl = smack_cipso_direct;
1291                         smack_set_catset(smack, nlsp);
1292                 }
1293                 break;
1294         default:
1295                 break;
1296         }
1297 }
1298
1299 /**
1300  * smack_netlabel - Set the secattr on a socket
1301  * @sk: the socket
1302  *
1303  * Convert the outbound smack value (smk_out) to a
1304  * secattr and attach it to the socket.
1305  *
1306  * Returns 0 on success or an error code
1307  */
1308 static int smack_netlabel(struct sock *sk)
1309 {
1310         struct socket_smack *ssp;
1311         struct netlbl_lsm_secattr secattr;
1312         int rc;
1313
1314         ssp = sk->sk_security;
1315         netlbl_secattr_init(&secattr);
1316         smack_to_secattr(ssp->smk_out, &secattr);
1317         rc = netlbl_sock_setattr(sk, &secattr);
1318         netlbl_secattr_destroy(&secattr);
1319
1320         return rc;
1321 }
1322
1323 /**
1324  * smack_inode_setsecurity - set smack xattrs
1325  * @inode: the object
1326  * @name: attribute name
1327  * @value: attribute value
1328  * @size: size of the attribute
1329  * @flags: unused
1330  *
1331  * Sets the named attribute in the appropriate blob
1332  *
1333  * Returns 0 on success, or an error code
1334  */
1335 static int smack_inode_setsecurity(struct inode *inode, const char *name,
1336                                    const void *value, size_t size, int flags)
1337 {
1338         char *sp;
1339         struct inode_smack *nsp = inode->i_security;
1340         struct socket_smack *ssp;
1341         struct socket *sock;
1342         int rc = 0;
1343
1344         if (value == NULL || size > SMK_LABELLEN)
1345                 return -EACCES;
1346
1347         sp = smk_import(value, size);
1348         if (sp == NULL)
1349                 return -EINVAL;
1350
1351         if (strcmp(name, XATTR_SMACK_SUFFIX) == 0) {
1352                 nsp->smk_inode = sp;
1353                 return 0;
1354         }
1355         /*
1356          * The rest of the Smack xattrs are only on sockets.
1357          */
1358         if (inode->i_sb->s_magic != SOCKFS_MAGIC)
1359                 return -EOPNOTSUPP;
1360
1361         sock = SOCKET_I(inode);
1362         if (sock == NULL || sock->sk == NULL)
1363                 return -EOPNOTSUPP;
1364
1365         ssp = sock->sk->sk_security;
1366
1367         if (strcmp(name, XATTR_SMACK_IPIN) == 0)
1368                 ssp->smk_in = sp;
1369         else if (strcmp(name, XATTR_SMACK_IPOUT) == 0) {
1370                 ssp->smk_out = sp;
1371                 rc = smack_netlabel(sock->sk);
1372                 if (rc != 0)
1373                         printk(KERN_WARNING "Smack: \"%s\" netlbl error %d.\n",
1374                                __func__, -rc);
1375         } else
1376                 return -EOPNOTSUPP;
1377
1378         return 0;
1379 }
1380
1381 /**
1382  * smack_socket_post_create - finish socket setup
1383  * @sock: the socket
1384  * @family: protocol family
1385  * @type: unused
1386  * @protocol: unused
1387  * @kern: unused
1388  *
1389  * Sets the netlabel information on the socket
1390  *
1391  * Returns 0 on success, and error code otherwise
1392  */
1393 static int smack_socket_post_create(struct socket *sock, int family,
1394                                     int type, int protocol, int kern)
1395 {
1396         if (family != PF_INET || sock->sk == NULL)
1397                 return 0;
1398         /*
1399          * Set the outbound netlbl.
1400          */
1401         return smack_netlabel(sock->sk);
1402 }
1403
1404 /**
1405  * smack_flags_to_may - convert S_ to MAY_ values
1406  * @flags: the S_ value
1407  *
1408  * Returns the equivalent MAY_ value
1409  */
1410 static int smack_flags_to_may(int flags)
1411 {
1412         int may = 0;
1413
1414         if (flags & S_IRUGO)
1415                 may |= MAY_READ;
1416         if (flags & S_IWUGO)
1417                 may |= MAY_WRITE;
1418         if (flags & S_IXUGO)
1419                 may |= MAY_EXEC;
1420
1421         return may;
1422 }
1423
1424 /**
1425  * smack_msg_msg_alloc_security - Set the security blob for msg_msg
1426  * @msg: the object
1427  *
1428  * Returns 0
1429  */
1430 static int smack_msg_msg_alloc_security(struct msg_msg *msg)
1431 {
1432         msg->security = current->security;
1433         return 0;
1434 }
1435
1436 /**
1437  * smack_msg_msg_free_security - Clear the security blob for msg_msg
1438  * @msg: the object
1439  *
1440  * Clears the blob pointer
1441  */
1442 static void smack_msg_msg_free_security(struct msg_msg *msg)
1443 {
1444         msg->security = NULL;
1445 }
1446
1447 /**
1448  * smack_of_shm - the smack pointer for the shm
1449  * @shp: the object
1450  *
1451  * Returns a pointer to the smack value
1452  */
1453 static char *smack_of_shm(struct shmid_kernel *shp)
1454 {
1455         return (char *)shp->shm_perm.security;
1456 }
1457
1458 /**
1459  * smack_shm_alloc_security - Set the security blob for shm
1460  * @shp: the object
1461  *
1462  * Returns 0
1463  */
1464 static int smack_shm_alloc_security(struct shmid_kernel *shp)
1465 {
1466         struct kern_ipc_perm *isp = &shp->shm_perm;
1467
1468         isp->security = current->security;
1469         return 0;
1470 }
1471
1472 /**
1473  * smack_shm_free_security - Clear the security blob for shm
1474  * @shp: the object
1475  *
1476  * Clears the blob pointer
1477  */
1478 static void smack_shm_free_security(struct shmid_kernel *shp)
1479 {
1480         struct kern_ipc_perm *isp = &shp->shm_perm;
1481
1482         isp->security = NULL;
1483 }
1484
1485 /**
1486  * smack_shm_associate - Smack access check for shm
1487  * @shp: the object
1488  * @shmflg: access requested
1489  *
1490  * Returns 0 if current has the requested access, error code otherwise
1491  */
1492 static int smack_shm_associate(struct shmid_kernel *shp, int shmflg)
1493 {
1494         char *ssp = smack_of_shm(shp);
1495         int may;
1496
1497         may = smack_flags_to_may(shmflg);
1498         return smk_curacc(ssp, may);
1499 }
1500
1501 /**
1502  * smack_shm_shmctl - Smack access check for shm
1503  * @shp: the object
1504  * @cmd: what it wants to do
1505  *
1506  * Returns 0 if current has the requested access, error code otherwise
1507  */
1508 static int smack_shm_shmctl(struct shmid_kernel *shp, int cmd)
1509 {
1510         char *ssp;
1511         int may;
1512
1513         switch (cmd) {
1514         case IPC_STAT:
1515         case SHM_STAT:
1516                 may = MAY_READ;
1517                 break;
1518         case IPC_SET:
1519         case SHM_LOCK:
1520         case SHM_UNLOCK:
1521         case IPC_RMID:
1522                 may = MAY_READWRITE;
1523                 break;
1524         case IPC_INFO:
1525         case SHM_INFO:
1526                 /*
1527                  * System level information.
1528                  */
1529                 return 0;
1530         default:
1531                 return -EINVAL;
1532         }
1533
1534         ssp = smack_of_shm(shp);
1535         return smk_curacc(ssp, may);
1536 }
1537
1538 /**
1539  * smack_shm_shmat - Smack access for shmat
1540  * @shp: the object
1541  * @shmaddr: unused
1542  * @shmflg: access requested
1543  *
1544  * Returns 0 if current has the requested access, error code otherwise
1545  */
1546 static int smack_shm_shmat(struct shmid_kernel *shp, char __user *shmaddr,
1547                            int shmflg)
1548 {
1549         char *ssp = smack_of_shm(shp);
1550         int may;
1551
1552         may = smack_flags_to_may(shmflg);
1553         return smk_curacc(ssp, may);
1554 }
1555
1556 /**
1557  * smack_of_sem - the smack pointer for the sem
1558  * @sma: the object
1559  *
1560  * Returns a pointer to the smack value
1561  */
1562 static char *smack_of_sem(struct sem_array *sma)
1563 {
1564         return (char *)sma->sem_perm.security;
1565 }
1566
1567 /**
1568  * smack_sem_alloc_security - Set the security blob for sem
1569  * @sma: the object
1570  *
1571  * Returns 0
1572  */
1573 static int smack_sem_alloc_security(struct sem_array *sma)
1574 {
1575         struct kern_ipc_perm *isp = &sma->sem_perm;
1576
1577         isp->security = current->security;
1578         return 0;
1579 }
1580
1581 /**
1582  * smack_sem_free_security - Clear the security blob for sem
1583  * @sma: the object
1584  *
1585  * Clears the blob pointer
1586  */
1587 static void smack_sem_free_security(struct sem_array *sma)
1588 {
1589         struct kern_ipc_perm *isp = &sma->sem_perm;
1590
1591         isp->security = NULL;
1592 }
1593
1594 /**
1595  * smack_sem_associate - Smack access check for sem
1596  * @sma: the object
1597  * @semflg: access requested
1598  *
1599  * Returns 0 if current has the requested access, error code otherwise
1600  */
1601 static int smack_sem_associate(struct sem_array *sma, int semflg)
1602 {
1603         char *ssp = smack_of_sem(sma);
1604         int may;
1605
1606         may = smack_flags_to_may(semflg);
1607         return smk_curacc(ssp, may);
1608 }
1609
1610 /**
1611  * smack_sem_shmctl - Smack access check for sem
1612  * @sma: the object
1613  * @cmd: what it wants to do
1614  *
1615  * Returns 0 if current has the requested access, error code otherwise
1616  */
1617 static int smack_sem_semctl(struct sem_array *sma, int cmd)
1618 {
1619         char *ssp;
1620         int may;
1621
1622         switch (cmd) {
1623         case GETPID:
1624         case GETNCNT:
1625         case GETZCNT:
1626         case GETVAL:
1627         case GETALL:
1628         case IPC_STAT:
1629         case SEM_STAT:
1630                 may = MAY_READ;
1631                 break;
1632         case SETVAL:
1633         case SETALL:
1634         case IPC_RMID:
1635         case IPC_SET:
1636                 may = MAY_READWRITE;
1637                 break;
1638         case IPC_INFO:
1639         case SEM_INFO:
1640                 /*
1641                  * System level information
1642                  */
1643                 return 0;
1644         default:
1645                 return -EINVAL;
1646         }
1647
1648         ssp = smack_of_sem(sma);
1649         return smk_curacc(ssp, may);
1650 }
1651
1652 /**
1653  * smack_sem_semop - Smack checks of semaphore operations
1654  * @sma: the object
1655  * @sops: unused
1656  * @nsops: unused
1657  * @alter: unused
1658  *
1659  * Treated as read and write in all cases.
1660  *
1661  * Returns 0 if access is allowed, error code otherwise
1662  */
1663 static int smack_sem_semop(struct sem_array *sma, struct sembuf *sops,
1664                            unsigned nsops, int alter)
1665 {
1666         char *ssp = smack_of_sem(sma);
1667
1668         return smk_curacc(ssp, MAY_READWRITE);
1669 }
1670
1671 /**
1672  * smack_msg_alloc_security - Set the security blob for msg
1673  * @msq: the object
1674  *
1675  * Returns 0
1676  */
1677 static int smack_msg_queue_alloc_security(struct msg_queue *msq)
1678 {
1679         struct kern_ipc_perm *kisp = &msq->q_perm;
1680
1681         kisp->security = current->security;
1682         return 0;
1683 }
1684
1685 /**
1686  * smack_msg_free_security - Clear the security blob for msg
1687  * @msq: the object
1688  *
1689  * Clears the blob pointer
1690  */
1691 static void smack_msg_queue_free_security(struct msg_queue *msq)
1692 {
1693         struct kern_ipc_perm *kisp = &msq->q_perm;
1694
1695         kisp->security = NULL;
1696 }
1697
1698 /**
1699  * smack_of_msq - the smack pointer for the msq
1700  * @msq: the object
1701  *
1702  * Returns a pointer to the smack value
1703  */
1704 static char *smack_of_msq(struct msg_queue *msq)
1705 {
1706         return (char *)msq->q_perm.security;
1707 }
1708
1709 /**
1710  * smack_msg_queue_associate - Smack access check for msg_queue
1711  * @msq: the object
1712  * @msqflg: access requested
1713  *
1714  * Returns 0 if current has the requested access, error code otherwise
1715  */
1716 static int smack_msg_queue_associate(struct msg_queue *msq, int msqflg)
1717 {
1718         char *msp = smack_of_msq(msq);
1719         int may;
1720
1721         may = smack_flags_to_may(msqflg);
1722         return smk_curacc(msp, may);
1723 }
1724
1725 /**
1726  * smack_msg_queue_msgctl - Smack access check for msg_queue
1727  * @msq: the object
1728  * @cmd: what it wants to do
1729  *
1730  * Returns 0 if current has the requested access, error code otherwise
1731  */
1732 static int smack_msg_queue_msgctl(struct msg_queue *msq, int cmd)
1733 {
1734         char *msp;
1735         int may;
1736
1737         switch (cmd) {
1738         case IPC_STAT:
1739         case MSG_STAT:
1740                 may = MAY_READ;
1741                 break;
1742         case IPC_SET:
1743         case IPC_RMID:
1744                 may = MAY_READWRITE;
1745                 break;
1746         case IPC_INFO:
1747         case MSG_INFO:
1748                 /*
1749                  * System level information
1750                  */
1751                 return 0;
1752         default:
1753                 return -EINVAL;
1754         }
1755
1756         msp = smack_of_msq(msq);
1757         return smk_curacc(msp, may);
1758 }
1759
1760 /**
1761  * smack_msg_queue_msgsnd - Smack access check for msg_queue
1762  * @msq: the object
1763  * @msg: unused
1764  * @msqflg: access requested
1765  *
1766  * Returns 0 if current has the requested access, error code otherwise
1767  */
1768 static int smack_msg_queue_msgsnd(struct msg_queue *msq, struct msg_msg *msg,
1769                                   int msqflg)
1770 {
1771         char *msp = smack_of_msq(msq);
1772         int rc;
1773
1774         rc = smack_flags_to_may(msqflg);
1775         return smk_curacc(msp, rc);
1776 }
1777
1778 /**
1779  * smack_msg_queue_msgsnd - Smack access check for msg_queue
1780  * @msq: the object
1781  * @msg: unused
1782  * @target: unused
1783  * @type: unused
1784  * @mode: unused
1785  *
1786  * Returns 0 if current has read and write access, error code otherwise
1787  */
1788 static int smack_msg_queue_msgrcv(struct msg_queue *msq, struct msg_msg *msg,
1789                         struct task_struct *target, long type, int mode)
1790 {
1791         char *msp = smack_of_msq(msq);
1792
1793         return smk_curacc(msp, MAY_READWRITE);
1794 }
1795
1796 /**
1797  * smack_ipc_permission - Smack access for ipc_permission()
1798  * @ipp: the object permissions
1799  * @flag: access requested
1800  *
1801  * Returns 0 if current has read and write access, error code otherwise
1802  */
1803 static int smack_ipc_permission(struct kern_ipc_perm *ipp, short flag)
1804 {
1805         char *isp = ipp->security;
1806         int may;
1807
1808         may = smack_flags_to_may(flag);
1809         return smk_curacc(isp, may);
1810 }
1811
1812 /**
1813  * smack_ipc_getsecid - Extract smack security id
1814  * @ipcp: the object permissions
1815  * @secid: where result will be saved
1816  */
1817 static void smack_ipc_getsecid(struct kern_ipc_perm *ipp, u32 *secid)
1818 {
1819         char *smack = ipp->security;
1820
1821         *secid = smack_to_secid(smack);
1822 }
1823
1824 /* module stacking operations */
1825
1826 /**
1827  * smack_register_security - stack capability module
1828  * @name: module name
1829  * @ops: module operations - ignored
1830  *
1831  * Allow the capability module to register.
1832  */
1833 static int smack_register_security(const char *name,
1834                                    struct security_operations *ops)
1835 {
1836         if (strcmp(name, "capability") != 0)
1837                 return -EINVAL;
1838
1839         printk(KERN_INFO "%s:  Registering secondary module %s\n",
1840                __func__, name);
1841
1842         return 0;
1843 }
1844
1845 /**
1846  * smack_d_instantiate - Make sure the blob is correct on an inode
1847  * @opt_dentry: unused
1848  * @inode: the object
1849  *
1850  * Set the inode's security blob if it hasn't been done already.
1851  */
1852 static void smack_d_instantiate(struct dentry *opt_dentry, struct inode *inode)
1853 {
1854         struct super_block *sbp;
1855         struct superblock_smack *sbsp;
1856         struct inode_smack *isp;
1857         char *csp = current->security;
1858         char *fetched;
1859         char *final;
1860         struct dentry *dp;
1861
1862         if (inode == NULL)
1863                 return;
1864
1865         isp = inode->i_security;
1866
1867         mutex_lock(&isp->smk_lock);
1868         /*
1869          * If the inode is already instantiated
1870          * take the quick way out
1871          */
1872         if (isp->smk_flags & SMK_INODE_INSTANT)
1873                 goto unlockandout;
1874
1875         sbp = inode->i_sb;
1876         sbsp = sbp->s_security;
1877         /*
1878          * We're going to use the superblock default label
1879          * if there's no label on the file.
1880          */
1881         final = sbsp->smk_default;
1882
1883         /*
1884          * This is pretty hackish.
1885          * Casey says that we shouldn't have to do
1886          * file system specific code, but it does help
1887          * with keeping it simple.
1888          */
1889         switch (sbp->s_magic) {
1890         case SMACK_MAGIC:
1891                 /*
1892                  * Casey says that it's a little embarassing
1893                  * that the smack file system doesn't do
1894                  * extended attributes.
1895                  */
1896                 final = smack_known_star.smk_known;
1897                 break;
1898         case PIPEFS_MAGIC:
1899                 /*
1900                  * Casey says pipes are easy (?)
1901                  */
1902                 final = smack_known_star.smk_known;
1903                 break;
1904         case DEVPTS_SUPER_MAGIC:
1905                 /*
1906                  * devpts seems content with the label of the task.
1907                  * Programs that change smack have to treat the
1908                  * pty with respect.
1909                  */
1910                 final = csp;
1911                 break;
1912         case SOCKFS_MAGIC:
1913                 /*
1914                  * Casey says sockets get the smack of the task.
1915                  */
1916                 final = csp;
1917                 break;
1918         case PROC_SUPER_MAGIC:
1919                 /*
1920                  * Casey says procfs appears not to care.
1921                  * The superblock default suffices.
1922                  */
1923                 break;
1924         case TMPFS_MAGIC:
1925                 /*
1926                  * Device labels should come from the filesystem,
1927                  * but watch out, because they're volitile,
1928                  * getting recreated on every reboot.
1929                  */
1930                 final = smack_known_star.smk_known;
1931                 /*
1932                  * No break.
1933                  *
1934                  * If a smack value has been set we want to use it,
1935                  * but since tmpfs isn't giving us the opportunity
1936                  * to set mount options simulate setting the
1937                  * superblock default.
1938                  */
1939         default:
1940                 /*
1941                  * This isn't an understood special case.
1942                  * Get the value from the xattr.
1943                  *
1944                  * No xattr support means, alas, no SMACK label.
1945                  * Use the aforeapplied default.
1946                  * It would be curious if the label of the task
1947                  * does not match that assigned.
1948                  */
1949                 if (inode->i_op->getxattr == NULL)
1950                         break;
1951                 /*
1952                  * Get the dentry for xattr.
1953                  */
1954                 if (opt_dentry == NULL) {
1955                         dp = d_find_alias(inode);
1956                         if (dp == NULL)
1957                                 break;
1958                 } else {
1959                         dp = dget(opt_dentry);
1960                         if (dp == NULL)
1961                                 break;
1962                 }
1963
1964                 fetched = smk_fetch(inode, dp);
1965                 if (fetched != NULL)
1966                         final = fetched;
1967
1968                 dput(dp);
1969                 break;
1970         }
1971
1972         if (final == NULL)
1973                 isp->smk_inode = csp;
1974         else
1975                 isp->smk_inode = final;
1976
1977         isp->smk_flags |= SMK_INODE_INSTANT;
1978
1979 unlockandout:
1980         mutex_unlock(&isp->smk_lock);
1981         return;
1982 }
1983
1984 /**
1985  * smack_getprocattr - Smack process attribute access
1986  * @p: the object task
1987  * @name: the name of the attribute in /proc/.../attr
1988  * @value: where to put the result
1989  *
1990  * Places a copy of the task Smack into value
1991  *
1992  * Returns the length of the smack label or an error code
1993  */
1994 static int smack_getprocattr(struct task_struct *p, char *name, char **value)
1995 {
1996         char *cp;
1997         int slen;
1998
1999         if (strcmp(name, "current") != 0)
2000                 return -EINVAL;
2001
2002         cp = kstrdup(p->security, GFP_KERNEL);
2003         if (cp == NULL)
2004                 return -ENOMEM;
2005
2006         slen = strlen(cp);
2007         *value = cp;
2008         return slen;
2009 }
2010
2011 /**
2012  * smack_setprocattr - Smack process attribute setting
2013  * @p: the object task
2014  * @name: the name of the attribute in /proc/.../attr
2015  * @value: the value to set
2016  * @size: the size of the value
2017  *
2018  * Sets the Smack value of the task. Only setting self
2019  * is permitted and only with privilege
2020  *
2021  * Returns the length of the smack label or an error code
2022  */
2023 static int smack_setprocattr(struct task_struct *p, char *name,
2024                              void *value, size_t size)
2025 {
2026         char *newsmack;
2027
2028         if (!__capable(p, CAP_MAC_ADMIN))
2029                 return -EPERM;
2030
2031         /*
2032          * Changing another process' Smack value is too dangerous
2033          * and supports no sane use case.
2034          */
2035         if (p != current)
2036                 return -EPERM;
2037
2038         if (value == NULL || size == 0 || size >= SMK_LABELLEN)
2039                 return -EINVAL;
2040
2041         if (strcmp(name, "current") != 0)
2042                 return -EINVAL;
2043
2044         newsmack = smk_import(value, size);
2045         if (newsmack == NULL)
2046                 return -EINVAL;
2047
2048         p->security = newsmack;
2049         return size;
2050 }
2051
2052 /**
2053  * smack_unix_stream_connect - Smack access on UDS
2054  * @sock: one socket
2055  * @other: the other socket
2056  * @newsk: unused
2057  *
2058  * Return 0 if a subject with the smack of sock could access
2059  * an object with the smack of other, otherwise an error code
2060  */
2061 static int smack_unix_stream_connect(struct socket *sock,
2062                                      struct socket *other, struct sock *newsk)
2063 {
2064         struct inode *sp = SOCK_INODE(sock);
2065         struct inode *op = SOCK_INODE(other);
2066
2067         return smk_access(smk_of_inode(sp), smk_of_inode(op), MAY_READWRITE);
2068 }
2069
2070 /**
2071  * smack_unix_may_send - Smack access on UDS
2072  * @sock: one socket
2073  * @other: the other socket
2074  *
2075  * Return 0 if a subject with the smack of sock could access
2076  * an object with the smack of other, otherwise an error code
2077  */
2078 static int smack_unix_may_send(struct socket *sock, struct socket *other)
2079 {
2080         struct inode *sp = SOCK_INODE(sock);
2081         struct inode *op = SOCK_INODE(other);
2082
2083         return smk_access(smk_of_inode(sp), smk_of_inode(op), MAY_WRITE);
2084 }
2085
2086 /**
2087  * smack_from_secattr - Convert a netlabel attr.mls.lvl/attr.mls.cat
2088  *      pair to smack
2089  * @sap: netlabel secattr
2090  * @sip: where to put the result
2091  *
2092  * Copies a smack label into sip
2093  */
2094 static void smack_from_secattr(struct netlbl_lsm_secattr *sap, char *sip)
2095 {
2096         char smack[SMK_LABELLEN];
2097         int pcat;
2098
2099         if ((sap->flags & NETLBL_SECATTR_MLS_LVL) == 0) {
2100                 /*
2101                  * If there are flags but no level netlabel isn't
2102                  * behaving the way we expect it to.
2103                  *
2104                  * Without guidance regarding the smack value
2105                  * for the packet fall back on the network
2106                  * ambient value.
2107                  */
2108                 strncpy(sip, smack_net_ambient, SMK_MAXLEN);
2109                 return;
2110         }
2111         /*
2112          * Get the categories, if any
2113          */
2114         memset(smack, '\0', SMK_LABELLEN);
2115         if ((sap->flags & NETLBL_SECATTR_MLS_CAT) != 0)
2116                 for (pcat = -1;;) {
2117                         pcat = netlbl_secattr_catmap_walk(sap->attr.mls.cat,
2118                                                           pcat + 1);
2119                         if (pcat < 0)
2120                                 break;
2121                         smack_catset_bit(pcat, smack);
2122                 }
2123         /*
2124          * If it is CIPSO using smack direct mapping
2125          * we are already done. WeeHee.
2126          */
2127         if (sap->attr.mls.lvl == smack_cipso_direct) {
2128                 memcpy(sip, smack, SMK_MAXLEN);
2129                 return;
2130         }
2131         /*
2132          * Look it up in the supplied table if it is not a direct mapping.
2133          */
2134         smack_from_cipso(sap->attr.mls.lvl, smack, sip);
2135         return;
2136 }
2137
2138 /**
2139  * smack_socket_sock_rcv_skb - Smack packet delivery access check
2140  * @sk: socket
2141  * @skb: packet
2142  *
2143  * Returns 0 if the packet should be delivered, an error code otherwise
2144  */
2145 static int smack_socket_sock_rcv_skb(struct sock *sk, struct sk_buff *skb)
2146 {
2147         struct netlbl_lsm_secattr secattr;
2148         struct socket_smack *ssp = sk->sk_security;
2149         char smack[SMK_LABELLEN];
2150         int rc;
2151
2152         if (sk->sk_family != PF_INET && sk->sk_family != PF_INET6)
2153                 return 0;
2154
2155         /*
2156          * Translate what netlabel gave us.
2157          */
2158         memset(smack, '\0', SMK_LABELLEN);
2159         netlbl_secattr_init(&secattr);
2160         rc = netlbl_skbuff_getattr(skb, sk->sk_family, &secattr);
2161         if (rc == 0)
2162                 smack_from_secattr(&secattr, smack);
2163         else
2164                 strncpy(smack, smack_net_ambient, SMK_MAXLEN);
2165         netlbl_secattr_destroy(&secattr);
2166         /*
2167          * Receiving a packet requires that the other end
2168          * be able to write here. Read access is not required.
2169          * This is the simplist possible security model
2170          * for networking.
2171          */
2172         return smk_access(smack, ssp->smk_in, MAY_WRITE);
2173 }
2174
2175 /**
2176  * smack_socket_getpeersec_stream - pull in packet label
2177  * @sock: the socket
2178  * @optval: user's destination
2179  * @optlen: size thereof
2180  * @len: max thereoe
2181  *
2182  * returns zero on success, an error code otherwise
2183  */
2184 static int smack_socket_getpeersec_stream(struct socket *sock,
2185                                           char __user *optval,
2186                                           int __user *optlen, unsigned len)
2187 {
2188         struct socket_smack *ssp;
2189         int slen;
2190         int rc = 0;
2191
2192         ssp = sock->sk->sk_security;
2193         slen = strlen(ssp->smk_packet) + 1;
2194
2195         if (slen > len)
2196                 rc = -ERANGE;
2197         else if (copy_to_user(optval, ssp->smk_packet, slen) != 0)
2198                 rc = -EFAULT;
2199
2200         if (put_user(slen, optlen) != 0)
2201                 rc = -EFAULT;
2202
2203         return rc;
2204 }
2205
2206
2207 /**
2208  * smack_socket_getpeersec_dgram - pull in packet label
2209  * @sock: the socket
2210  * @skb: packet data
2211  * @secid: pointer to where to put the secid of the packet
2212  *
2213  * Sets the netlabel socket state on sk from parent
2214  */
2215 static int smack_socket_getpeersec_dgram(struct socket *sock,
2216                                          struct sk_buff *skb, u32 *secid)
2217
2218 {
2219         struct netlbl_lsm_secattr secattr;
2220         struct sock *sk;
2221         char smack[SMK_LABELLEN];
2222         int family = PF_INET;
2223         u32 s;
2224         int rc;
2225
2226         /*
2227          * Only works for families with packets.
2228          */
2229         if (sock != NULL) {
2230                 sk = sock->sk;
2231                 if (sk->sk_family != PF_INET && sk->sk_family != PF_INET6)
2232                         return 0;
2233                 family = sk->sk_family;
2234         }
2235         /*
2236          * Translate what netlabel gave us.
2237          */
2238         memset(smack, '\0', SMK_LABELLEN);
2239         netlbl_secattr_init(&secattr);
2240         rc = netlbl_skbuff_getattr(skb, family, &secattr);
2241         if (rc == 0)
2242                 smack_from_secattr(&secattr, smack);
2243         netlbl_secattr_destroy(&secattr);
2244
2245         /*
2246          * Give up if we couldn't get anything
2247          */
2248         if (rc != 0)
2249                 return rc;
2250
2251         s = smack_to_secid(smack);
2252         if (s == 0)
2253                 return -EINVAL;
2254
2255         *secid = s;
2256         return 0;
2257 }
2258
2259 /**
2260  * smack_sock_graft - graft access state between two sockets
2261  * @sk: fresh sock
2262  * @parent: donor socket
2263  *
2264  * Sets the netlabel socket state on sk from parent
2265  */
2266 static void smack_sock_graft(struct sock *sk, struct socket *parent)
2267 {
2268         struct socket_smack *ssp;
2269         int rc;
2270
2271         if (sk == NULL)
2272                 return;
2273
2274         if (sk->sk_family != PF_INET && sk->sk_family != PF_INET6)
2275                 return;
2276
2277         ssp = sk->sk_security;
2278         ssp->smk_in = current->security;
2279         ssp->smk_out = current->security;
2280         ssp->smk_packet[0] = '\0';
2281
2282         rc = smack_netlabel(sk);
2283         if (rc != 0)
2284                 printk(KERN_WARNING "Smack: \"%s\" netlbl error %d.\n",
2285                        __func__, -rc);
2286 }
2287
2288 /**
2289  * smack_inet_conn_request - Smack access check on connect
2290  * @sk: socket involved
2291  * @skb: packet
2292  * @req: unused
2293  *
2294  * Returns 0 if a task with the packet label could write to
2295  * the socket, otherwise an error code
2296  */
2297 static int smack_inet_conn_request(struct sock *sk, struct sk_buff *skb,
2298                                    struct request_sock *req)
2299 {
2300         struct netlbl_lsm_secattr skb_secattr;
2301         struct socket_smack *ssp = sk->sk_security;
2302         char smack[SMK_LABELLEN];
2303         int rc;
2304
2305         if (skb == NULL)
2306                 return -EACCES;
2307
2308         memset(smack, '\0', SMK_LABELLEN);
2309         netlbl_secattr_init(&skb_secattr);
2310         rc = netlbl_skbuff_getattr(skb, sk->sk_family, &skb_secattr);
2311         if (rc == 0)
2312                 smack_from_secattr(&skb_secattr, smack);
2313         else
2314                 strncpy(smack, smack_known_huh.smk_known, SMK_MAXLEN);
2315         netlbl_secattr_destroy(&skb_secattr);
2316         /*
2317          * Receiving a packet requires that the other end
2318          * be able to write here. Read access is not required.
2319          *
2320          * If the request is successful save the peer's label
2321          * so that SO_PEERCRED can report it.
2322          */
2323         rc = smk_access(smack, ssp->smk_in, MAY_WRITE);
2324         if (rc == 0)
2325                 strncpy(ssp->smk_packet, smack, SMK_MAXLEN);
2326
2327         return rc;
2328 }
2329
2330 /*
2331  * Key management security hooks
2332  *
2333  * Casey has not tested key support very heavily.
2334  * The permission check is most likely too restrictive.
2335  * If you care about keys please have a look.
2336  */
2337 #ifdef CONFIG_KEYS
2338
2339 /**
2340  * smack_key_alloc - Set the key security blob
2341  * @key: object
2342  * @tsk: the task associated with the key
2343  * @flags: unused
2344  *
2345  * No allocation required
2346  *
2347  * Returns 0
2348  */
2349 static int smack_key_alloc(struct key *key, struct task_struct *tsk,
2350                            unsigned long flags)
2351 {
2352         key->security = tsk->security;
2353         return 0;
2354 }
2355
2356 /**
2357  * smack_key_free - Clear the key security blob
2358  * @key: the object
2359  *
2360  * Clear the blob pointer
2361  */
2362 static void smack_key_free(struct key *key)
2363 {
2364         key->security = NULL;
2365 }
2366
2367 /*
2368  * smack_key_permission - Smack access on a key
2369  * @key_ref: gets to the object
2370  * @context: task involved
2371  * @perm: unused
2372  *
2373  * Return 0 if the task has read and write to the object,
2374  * an error code otherwise
2375  */
2376 static int smack_key_permission(key_ref_t key_ref,
2377                                 struct task_struct *context, key_perm_t perm)
2378 {
2379         struct key *keyp;
2380
2381         keyp = key_ref_to_ptr(key_ref);
2382         if (keyp == NULL)
2383                 return -EINVAL;
2384         /*
2385          * If the key hasn't been initialized give it access so that
2386          * it may do so.
2387          */
2388         if (keyp->security == NULL)
2389                 return 0;
2390         /*
2391          * This should not occur
2392          */
2393         if (context->security == NULL)
2394                 return -EACCES;
2395
2396         return smk_access(context->security, keyp->security, MAY_READWRITE);
2397 }
2398 #endif /* CONFIG_KEYS */
2399
2400 /*
2401  * Smack Audit hooks
2402  *
2403  * Audit requires a unique representation of each Smack specific
2404  * rule. This unique representation is used to distinguish the
2405  * object to be audited from remaining kernel objects and also
2406  * works as a glue between the audit hooks.
2407  *
2408  * Since repository entries are added but never deleted, we'll use
2409  * the smack_known label address related to the given audit rule as
2410  * the needed unique representation. This also better fits the smack
2411  * model where nearly everything is a label.
2412  */
2413 #ifdef CONFIG_AUDIT
2414
2415 /**
2416  * smack_audit_rule_init - Initialize a smack audit rule
2417  * @field: audit rule fields given from user-space (audit.h)
2418  * @op: required testing operator (=, !=, >, <, ...)
2419  * @rulestr: smack label to be audited
2420  * @vrule: pointer to save our own audit rule representation
2421  *
2422  * Prepare to audit cases where (@field @op @rulestr) is true.
2423  * The label to be audited is created if necessay.
2424  */
2425 static int smack_audit_rule_init(u32 field, u32 op, char *rulestr, void **vrule)
2426 {
2427         char **rule = (char **)vrule;
2428         *rule = NULL;
2429
2430         if (field != AUDIT_SUBJ_USER && field != AUDIT_OBJ_USER)
2431                 return -EINVAL;
2432
2433         if (op != AUDIT_EQUAL && op != AUDIT_NOT_EQUAL)
2434                 return -EINVAL;
2435
2436         *rule = smk_import(rulestr, 0);
2437
2438         return 0;
2439 }
2440
2441 /**
2442  * smack_audit_rule_known - Distinguish Smack audit rules
2443  * @krule: rule of interest, in Audit kernel representation format
2444  *
2445  * This is used to filter Smack rules from remaining Audit ones.
2446  * If it's proved that this rule belongs to us, the
2447  * audit_rule_match hook will be called to do the final judgement.
2448  */
2449 static int smack_audit_rule_known(struct audit_krule *krule)
2450 {
2451         struct audit_field *f;
2452         int i;
2453
2454         for (i = 0; i < krule->field_count; i++) {
2455                 f = &krule->fields[i];
2456
2457                 if (f->type == AUDIT_SUBJ_USER || f->type == AUDIT_OBJ_USER)
2458                         return 1;
2459         }
2460
2461         return 0;
2462 }
2463
2464 /**
2465  * smack_audit_rule_match - Audit given object ?
2466  * @secid: security id for identifying the object to test
2467  * @field: audit rule flags given from user-space
2468  * @op: required testing operator
2469  * @vrule: smack internal rule presentation
2470  * @actx: audit context associated with the check
2471  *
2472  * The core Audit hook. It's used to take the decision of
2473  * whether to audit or not to audit a given object.
2474  */
2475 static int smack_audit_rule_match(u32 secid, u32 field, u32 op, void *vrule,
2476                                   struct audit_context *actx)
2477 {
2478         char *smack;
2479         char *rule = vrule;
2480
2481         if (!rule) {
2482                 audit_log(actx, GFP_KERNEL, AUDIT_SELINUX_ERR,
2483                           "Smack: missing rule\n");
2484                 return -ENOENT;
2485         }
2486
2487         if (field != AUDIT_SUBJ_USER && field != AUDIT_OBJ_USER)
2488                 return 0;
2489
2490         smack = smack_from_secid(secid);
2491
2492         /*
2493          * No need to do string comparisons. If a match occurs,
2494          * both pointers will point to the same smack_known
2495          * label.
2496          */
2497         if (op == AUDIT_EQUAL)
2498                 return (rule == smack);
2499         if (op == AUDIT_NOT_EQUAL)
2500                 return (rule != smack);
2501
2502         return 0;
2503 }
2504
2505 /**
2506  * smack_audit_rule_free - free smack rule representation
2507  * @vrule: rule to be freed.
2508  *
2509  * No memory was allocated.
2510  */
2511 static void smack_audit_rule_free(void *vrule)
2512 {
2513         /* No-op */
2514 }
2515
2516 #endif /* CONFIG_AUDIT */
2517
2518 /*
2519  * smack_secid_to_secctx - return the smack label for a secid
2520  * @secid: incoming integer
2521  * @secdata: destination
2522  * @seclen: how long it is
2523  *
2524  * Exists for networking code.
2525  */
2526 static int smack_secid_to_secctx(u32 secid, char **secdata, u32 *seclen)
2527 {
2528         char *sp = smack_from_secid(secid);
2529
2530         *secdata = sp;
2531         *seclen = strlen(sp);
2532         return 0;
2533 }
2534
2535 /*
2536  * smack_secctx_to_secid - return the secid for a smack label
2537  * @secdata: smack label
2538  * @seclen: how long result is
2539  * @secid: outgoing integer
2540  *
2541  * Exists for audit and networking code.
2542  */
2543 static int smack_secctx_to_secid(const char *secdata, u32 seclen, u32 *secid)
2544 {
2545         *secid = smack_to_secid(secdata);
2546         return 0;
2547 }
2548
2549 /*
2550  * smack_release_secctx - don't do anything.
2551  * @key_ref: unused
2552  * @context: unused
2553  * @perm: unused
2554  *
2555  * Exists to make sure nothing gets done, and properly
2556  */
2557 static void smack_release_secctx(char *secdata, u32 seclen)
2558 {
2559 }
2560
2561 struct security_operations smack_ops = {
2562         .name =                         "smack",
2563
2564         .ptrace =                       smack_ptrace,
2565         .capget =                       cap_capget,
2566         .capset_check =                 cap_capset_check,
2567         .capset_set =                   cap_capset_set,
2568         .capable =                      cap_capable,
2569         .syslog =                       smack_syslog,
2570         .settime =                      cap_settime,
2571         .vm_enough_memory =             cap_vm_enough_memory,
2572
2573         .bprm_apply_creds =             cap_bprm_apply_creds,
2574         .bprm_set_security =            cap_bprm_set_security,
2575         .bprm_secureexec =              cap_bprm_secureexec,
2576
2577         .sb_alloc_security =            smack_sb_alloc_security,
2578         .sb_free_security =             smack_sb_free_security,
2579         .sb_copy_data =                 smack_sb_copy_data,
2580         .sb_kern_mount =                smack_sb_kern_mount,
2581         .sb_statfs =                    smack_sb_statfs,
2582         .sb_mount =                     smack_sb_mount,
2583         .sb_umount =                    smack_sb_umount,
2584
2585         .inode_alloc_security =         smack_inode_alloc_security,
2586         .inode_free_security =          smack_inode_free_security,
2587         .inode_init_security =          smack_inode_init_security,
2588         .inode_link =                   smack_inode_link,
2589         .inode_unlink =                 smack_inode_unlink,
2590         .inode_rmdir =                  smack_inode_rmdir,
2591         .inode_rename =                 smack_inode_rename,
2592         .inode_permission =             smack_inode_permission,
2593         .inode_setattr =                smack_inode_setattr,
2594         .inode_getattr =                smack_inode_getattr,
2595         .inode_setxattr =               smack_inode_setxattr,
2596         .inode_post_setxattr =          smack_inode_post_setxattr,
2597         .inode_getxattr =               smack_inode_getxattr,
2598         .inode_removexattr =            smack_inode_removexattr,
2599         .inode_need_killpriv =          cap_inode_need_killpriv,
2600         .inode_killpriv =               cap_inode_killpriv,
2601         .inode_getsecurity =            smack_inode_getsecurity,
2602         .inode_setsecurity =            smack_inode_setsecurity,
2603         .inode_listsecurity =           smack_inode_listsecurity,
2604         .inode_getsecid =               smack_inode_getsecid,
2605
2606         .file_permission =              smack_file_permission,
2607         .file_alloc_security =          smack_file_alloc_security,
2608         .file_free_security =           smack_file_free_security,
2609         .file_ioctl =                   smack_file_ioctl,
2610         .file_lock =                    smack_file_lock,
2611         .file_fcntl =                   smack_file_fcntl,
2612         .file_set_fowner =              smack_file_set_fowner,
2613         .file_send_sigiotask =          smack_file_send_sigiotask,
2614         .file_receive =                 smack_file_receive,
2615
2616         .task_alloc_security =          smack_task_alloc_security,
2617         .task_free_security =           smack_task_free_security,
2618         .task_post_setuid =             cap_task_post_setuid,
2619         .task_setpgid =                 smack_task_setpgid,
2620         .task_getpgid =                 smack_task_getpgid,
2621         .task_getsid =                  smack_task_getsid,
2622         .task_getsecid =                smack_task_getsecid,
2623         .task_setnice =                 smack_task_setnice,
2624         .task_setioprio =               smack_task_setioprio,
2625         .task_getioprio =               smack_task_getioprio,
2626         .task_setscheduler =            smack_task_setscheduler,
2627         .task_getscheduler =            smack_task_getscheduler,
2628         .task_movememory =              smack_task_movememory,
2629         .task_kill =                    smack_task_kill,
2630         .task_wait =                    smack_task_wait,
2631         .task_reparent_to_init =        cap_task_reparent_to_init,
2632         .task_to_inode =                smack_task_to_inode,
2633         .task_prctl =                   cap_task_prctl,
2634
2635         .ipc_permission =               smack_ipc_permission,
2636         .ipc_getsecid =                 smack_ipc_getsecid,
2637
2638         .msg_msg_alloc_security =       smack_msg_msg_alloc_security,
2639         .msg_msg_free_security =        smack_msg_msg_free_security,
2640
2641         .msg_queue_alloc_security =     smack_msg_queue_alloc_security,
2642         .msg_queue_free_security =      smack_msg_queue_free_security,
2643         .msg_queue_associate =          smack_msg_queue_associate,
2644         .msg_queue_msgctl =             smack_msg_queue_msgctl,
2645         .msg_queue_msgsnd =             smack_msg_queue_msgsnd,
2646         .msg_queue_msgrcv =             smack_msg_queue_msgrcv,
2647
2648         .shm_alloc_security =           smack_shm_alloc_security,
2649         .shm_free_security =            smack_shm_free_security,
2650         .shm_associate =                smack_shm_associate,
2651         .shm_shmctl =                   smack_shm_shmctl,
2652         .shm_shmat =                    smack_shm_shmat,
2653
2654         .sem_alloc_security =           smack_sem_alloc_security,
2655         .sem_free_security =            smack_sem_free_security,
2656         .sem_associate =                smack_sem_associate,
2657         .sem_semctl =                   smack_sem_semctl,
2658         .sem_semop =                    smack_sem_semop,
2659
2660         .netlink_send =                 cap_netlink_send,
2661         .netlink_recv =                 cap_netlink_recv,
2662
2663         .register_security =            smack_register_security,
2664
2665         .d_instantiate =                smack_d_instantiate,
2666
2667         .getprocattr =                  smack_getprocattr,
2668         .setprocattr =                  smack_setprocattr,
2669
2670         .unix_stream_connect =          smack_unix_stream_connect,
2671         .unix_may_send =                smack_unix_may_send,
2672
2673         .socket_post_create =           smack_socket_post_create,
2674         .socket_sock_rcv_skb =          smack_socket_sock_rcv_skb,
2675         .socket_getpeersec_stream =     smack_socket_getpeersec_stream,
2676         .socket_getpeersec_dgram =      smack_socket_getpeersec_dgram,
2677         .sk_alloc_security =            smack_sk_alloc_security,
2678         .sk_free_security =             smack_sk_free_security,
2679         .sock_graft =                   smack_sock_graft,
2680         .inet_conn_request =            smack_inet_conn_request,
2681
2682  /* key management security hooks */
2683 #ifdef CONFIG_KEYS
2684         .key_alloc =                    smack_key_alloc,
2685         .key_free =                     smack_key_free,
2686         .key_permission =               smack_key_permission,
2687 #endif /* CONFIG_KEYS */
2688
2689  /* Audit hooks */
2690 #ifdef CONFIG_AUDIT
2691         .audit_rule_init =              smack_audit_rule_init,
2692         .audit_rule_known =             smack_audit_rule_known,
2693         .audit_rule_match =             smack_audit_rule_match,
2694         .audit_rule_free =              smack_audit_rule_free,
2695 #endif /* CONFIG_AUDIT */
2696
2697         .secid_to_secctx =              smack_secid_to_secctx,
2698         .secctx_to_secid =              smack_secctx_to_secid,
2699         .release_secctx =               smack_release_secctx,
2700 };
2701
2702 /**
2703  * smack_init - initialize the smack system
2704  *
2705  * Returns 0
2706  */
2707 static __init int smack_init(void)
2708 {
2709         if (!security_module_enable(&smack_ops))
2710                 return 0;
2711
2712         printk(KERN_INFO "Smack:  Initializing.\n");
2713
2714         /*
2715          * Set the security state for the initial task.
2716          */
2717         current->security = &smack_known_floor.smk_known;
2718
2719         /*
2720          * Initialize locks
2721          */
2722         spin_lock_init(&smack_known_unset.smk_cipsolock);
2723         spin_lock_init(&smack_known_huh.smk_cipsolock);
2724         spin_lock_init(&smack_known_hat.smk_cipsolock);
2725         spin_lock_init(&smack_known_star.smk_cipsolock);
2726         spin_lock_init(&smack_known_floor.smk_cipsolock);
2727         spin_lock_init(&smack_known_invalid.smk_cipsolock);
2728
2729         /*
2730          * Register with LSM
2731          */
2732         if (register_security(&smack_ops))
2733                 panic("smack: Unable to register with kernel.\n");
2734
2735         return 0;
2736 }
2737
2738 /*
2739  * Smack requires early initialization in order to label
2740  * all processes and objects when they are created.
2741  */
2742 security_initcall(smack_init);
2743