security/apparmor/lsm.c

   1 /*
   2  * AppArmor security module
   3  *
   4  * This file contains AppArmor LSM hooks.
   5  *
   6  * Copyright (C) 1998-2008 Novell/SUSE
   7  * Copyright 2009-2010 Canonical Ltd.
   8  *
   9  * This program is free software; you can redistribute it and/or
  10  * modify it under the terms of the GNU General Public License as
  11  * published by the Free Software Foundation, version 2 of the
  12  * License.
  13  */
  14
  15 #include <linux/lsm_hooks.h>
  16 #include <linux/moduleparam.h>
  17 #include <linux/mm.h>
  18 #include <linux/mman.h>
  19 #include <linux/mount.h>
  20 #include <linux/namei.h>
  21 #include <linux/ptrace.h>
  22 #include <linux/ctype.h>
  23 #include <linux/sysctl.h>
  24 #include <linux/audit.h>
  25 #include <linux/user_namespace.h>
  26 #include <net/sock.h>
  27
  28 #include "include/apparmor.h"
  29 #include "include/apparmorfs.h"
  30 #include "include/audit.h"
  31 #include "include/capability.h"
  32 #include "include/context.h"
  33 #include "include/file.h"
  34 #include "include/ipc.h"
  35 #include "include/path.h"
  36 #include "include/policy.h"
  37 #include "include/policy_ns.h"
  38 #include "include/procattr.h"
  39
  40 /* Flag indicating whether initialization completed */
  41 int apparmor_initialized __initdata;
  42
  43 /*
  44  * LSM hook functions
  45  */
  46
  47 /*
  48  * free the associated aa_task_cxt and put its profiles
  49  */
  50 static void apparmor_cred_free(struct cred *cred)
  51 {
  52         aa_free_task_context(cred_cxt(cred));
  53         cred_cxt(cred) = NULL;
  54 }
  55
  56 /*
  57  * allocate the apparmor part of blank credentials
  58  */
  59 static int apparmor_cred_alloc_blank(struct cred *cred, gfp_t gfp)
  60 {
  61         /* freed by apparmor_cred_free */
  62         struct aa_task_cxt *cxt = aa_alloc_task_context(gfp);
  63         if (!cxt)
  64                 return -ENOMEM;
  65
  66         cred_cxt(cred) = cxt;
  67         return 0;
  68 }
  69
  70 /*
  71  * prepare new aa_task_cxt for modification by prepare_cred block
  72  */
  73 static int apparmor_cred_prepare(struct cred *new, const struct cred *old,
  74                                  gfp_t gfp)
  75 {
  76         /* freed by apparmor_cred_free */
  77         struct aa_task_cxt *cxt = aa_alloc_task_context(gfp);
  78         if (!cxt)
  79                 return -ENOMEM;
  80
  81         aa_dup_task_context(cxt, cred_cxt(old));
  82         cred_cxt(new) = cxt;
  83         return 0;
  84 }
  85
  86 /*
  87  * transfer the apparmor data to a blank set of creds
  88  */
  89 static void apparmor_cred_transfer(struct cred *new, const struct cred *old)
  90 {
  91         const struct aa_task_cxt *old_cxt = cred_cxt(old);
  92         struct aa_task_cxt *new_cxt = cred_cxt(new);
  93
  94         aa_dup_task_context(new_cxt, old_cxt);
  95 }
  96
  97 static int apparmor_ptrace_access_check(struct task_struct *child,
  98                                         unsigned int mode)
  99 {
 100         return aa_ptrace(current, child, mode);
 101 }
 102
 103 static int apparmor_ptrace_traceme(struct task_struct *parent)
 104 {
 105         return aa_ptrace(parent, current, PTRACE_MODE_ATTACH);
 106 }
 107
 108 /* Derived from security/commoncap.c:cap_capget */
 109 static int apparmor_capget(struct task_struct *target, kernel_cap_t *effective,
 110                            kernel_cap_t *inheritable, kernel_cap_t *permitted)
 111 {
 112         struct aa_profile *profile;
 113         const struct cred *cred;
 114
 115         rcu_read_lock();
 116         cred = __task_cred(target);
 117         profile = aa_cred_profile(cred);
 118
 119         /*
 120          * cap_capget is stacked ahead of this and will
 121          * initialize effective and permitted.
 122          */
 123         if (!unconfined(profile) && !COMPLAIN_MODE(profile)) {
 124                 *effective = cap_intersect(*effective, profile->caps.allow);
 125                 *permitted = cap_intersect(*permitted, profile->caps.allow);
 126         }
 127         rcu_read_unlock();
 128
 129         return 0;
 130 }
 131
 132 static int apparmor_capable(const struct cred *cred, struct user_namespace *ns,
 133                             int cap, int audit)
 134 {
 135         struct aa_profile *profile;
 136         int error = 0;
 137
 138         profile = aa_cred_profile(cred);
 139         if (!unconfined(profile))
 140                 error = aa_capable(profile, cap, audit);
 141         return error;
 142 }
 143
 144 /**
 145  * common_perm - basic common permission check wrapper fn for paths
 146  * @op: operation being checked
 147  * @path: path to check permission of  (NOT NULL)
 148  * @mask: requested permissions mask
 149  * @cond: conditional info for the permission request  (NOT NULL)
 150  *
 151  * Returns: %0 else error code if error or permission denied
 152  */
 153 static int common_perm(int op, const struct path *path, u32 mask,
 154                        struct path_cond *cond)
 155 {
 156         struct aa_profile *profile;
 157         int error = 0;
 158
 159         profile = __aa_current_profile();
 160         if (!unconfined(profile))
 161                 error = aa_path_perm(op, profile, path, 0, mask, cond);
 162
 163         return error;
 164 }
 165
 166 /**
 167  * common_perm_dir_dentry - common permission wrapper when path is dir, dentry
 168  * @op: operation being checked
 169  * @dir: directory of the dentry  (NOT NULL)
 170  * @dentry: dentry to check  (NOT NULL)
 171  * @mask: requested permissions mask
 172  * @cond: conditional info for the permission request  (NOT NULL)
 173  *
 174  * Returns: %0 else error code if error or permission denied
 175  */
 176 static int common_perm_dir_dentry(int op, const struct path *dir,
 177                                   struct dentry *dentry, u32 mask,
 178                                   struct path_cond *cond)
 179 {
 180         struct path path = { .mnt = dir->mnt, .dentry = dentry };
 181
 182         return common_perm(op, &path, mask, cond);
 183 }
 184
 185 /**
 186  * common_perm_path - common permission wrapper when mnt, dentry
 187  * @op: operation being checked
 188  * @path: location to check (NOT NULL)
 189  * @mask: requested permissions mask
 190  *
 191  * Returns: %0 else error code if error or permission denied
 192  */
 193 static inline int common_perm_path(int op, const struct path *path, u32 mask)
 194 {
 195         struct path_cond cond = { d_backing_inode(path->dentry)->i_uid,
 196                                   d_backing_inode(path->dentry)->i_mode
 197         };
 198         if (!path_mediated_fs(path->dentry))
 199                 return 0;
 200
 201         return common_perm(op, path, mask, &cond);
 202 }
 203
 204 /**
 205  * common_perm_rm - common permission wrapper for operations doing rm
 206  * @op: operation being checked
 207  * @dir: directory that the dentry is in  (NOT NULL)
 208  * @dentry: dentry being rm'd  (NOT NULL)
 209  * @mask: requested permission mask
 210  *
 211  * Returns: %0 else error code if error or permission denied
 212  */
 213 static int common_perm_rm(int op, const struct path *dir,
 214                           struct dentry *dentry, u32 mask)
 215 {
 216         struct inode *inode = d_backing_inode(dentry);
 217         struct path_cond cond = { };
 218
 219         if (!inode || !path_mediated_fs(dentry))
 220                 return 0;
 221
 222         cond.uid = inode->i_uid;
 223         cond.mode = inode->i_mode;
 224
 225         return common_perm_dir_dentry(op, dir, dentry, mask, &cond);
 226 }
 227
 228 /**
 229  * common_perm_create - common permission wrapper for operations doing create
 230  * @op: operation being checked
 231  * @dir: directory that dentry will be created in  (NOT NULL)
 232  * @dentry: dentry to create   (NOT NULL)
 233  * @mask: request permission mask
 234  * @mode: created file mode
 235  *
 236  * Returns: %0 else error code if error or permission denied
 237  */
 238 static int common_perm_create(int op, const struct path *dir,
 239                               struct dentry *dentry, u32 mask, umode_t mode)
 240 {
 241         struct path_cond cond = { current_fsuid(), mode };
 242
 243         if (!path_mediated_fs(dir->dentry))
 244                 return 0;
 245
 246         return common_perm_dir_dentry(op, dir, dentry, mask, &cond);
 247 }
 248
 249 static int apparmor_path_unlink(const struct path *dir, struct dentry *dentry)
 250 {
 251         return common_perm_rm(OP_UNLINK, dir, dentry, AA_MAY_DELETE);
 252 }
 253
 254 static int apparmor_path_mkdir(const struct path *dir, struct dentry *dentry,
 255                                umode_t mode)
 256 {
 257         return common_perm_create(OP_MKDIR, dir, dentry, AA_MAY_CREATE,
 258                                   S_IFDIR);
 259 }
 260
 261 static int apparmor_path_rmdir(const struct path *dir, struct dentry *dentry)
 262 {
 263         return common_perm_rm(OP_RMDIR, dir, dentry, AA_MAY_DELETE);
 264 }
 265
 266 static int apparmor_path_mknod(const struct path *dir, struct dentry *dentry,
 267                                umode_t mode, unsigned int dev)
 268 {
 269         return common_perm_create(OP_MKNOD, dir, dentry, AA_MAY_CREATE, mode);
 270 }
 271
 272 static int apparmor_path_truncate(const struct path *path)
 273 {
 274         return common_perm_path(OP_TRUNC, path, MAY_WRITE | AA_MAY_META_WRITE);
 275 }
 276
 277 static int apparmor_path_symlink(const struct path *dir, struct dentry *dentry,
 278                                  const char *old_name)
 279 {
 280         return common_perm_create(OP_SYMLINK, dir, dentry, AA_MAY_CREATE,
 281                                   S_IFLNK);
 282 }
 283
 284 static int apparmor_path_link(struct dentry *old_dentry, const struct path *new_dir,
 285                               struct dentry *new_dentry)
 286 {
 287         struct aa_profile *profile;
 288         int error = 0;
 289
 290         if (!path_mediated_fs(old_dentry))
 291                 return 0;
 292
 293         profile = aa_current_profile();
 294         if (!unconfined(profile))
 295                 error = aa_path_link(profile, old_dentry, new_dir, new_dentry);
 296         return error;
 297 }
 298
 299 static int apparmor_path_rename(const struct path *old_dir, struct dentry *old_dentry,
 300                                 const struct path *new_dir, struct dentry *new_dentry)
 301 {
 302         struct aa_profile *profile;
 303         int error = 0;
 304
 305         if (!path_mediated_fs(old_dentry))
 306                 return 0;
 307
 308         profile = aa_current_profile();
 309         if (!unconfined(profile)) {
 310                 struct path old_path = { .mnt = old_dir->mnt,
 311                                          .dentry = old_dentry };
 312                 struct path new_path = { .mnt = new_dir->mnt,
 313                                          .dentry = new_dentry };
 314                 struct path_cond cond = { d_backing_inode(old_dentry)->i_uid,
 315                                           d_backing_inode(old_dentry)->i_mode
 316                 };
 317
 318                 error = aa_path_perm(OP_RENAME_SRC, profile, &old_path, 0,
 319                                      MAY_READ | AA_MAY_META_READ | MAY_WRITE |
 320                                      AA_MAY_META_WRITE | AA_MAY_DELETE,
 321                                      &cond);
 322                 if (!error)
 323                         error = aa_path_perm(OP_RENAME_DEST, profile, &new_path,
 324                                              0, MAY_WRITE | AA_MAY_META_WRITE |
 325                                              AA_MAY_CREATE, &cond);
 326
 327         }
 328         return error;
 329 }
 330
 331 static int apparmor_path_chmod(const struct path *path, umode_t mode)
 332 {
 333         return common_perm_path(OP_CHMOD, path, AA_MAY_CHMOD);
 334 }
 335
 336 static int apparmor_path_chown(const struct path *path, kuid_t uid, kgid_t gid)
 337 {
 338         return common_perm_path(OP_CHOWN, path, AA_MAY_CHOWN);
 339 }
 340
 341 static int apparmor_inode_getattr(const struct path *path)
 342 {
 343         return common_perm_path(OP_GETATTR, path, AA_MAY_META_READ);
 344 }
 345
 346 static int apparmor_file_open(struct file *file, const struct cred *cred)
 347 {
 348         struct aa_file_cxt *fcxt = file->f_security;
 349         struct aa_profile *profile;
 350         int error = 0;
 351
 352         if (!path_mediated_fs(file->f_path.dentry))
 353                 return 0;
 354
 355         /* If in exec, permission is handled by bprm hooks.
 356          * Cache permissions granted by the previous exec check, with
 357          * implicit read and executable mmap which are required to
 358          * actually execute the image.
 359          */
 360         if (current->in_execve) {
 361                 fcxt->allow = MAY_EXEC | MAY_READ | AA_EXEC_MMAP;
 362                 return 0;
 363         }
 364
 365         profile = aa_cred_profile(cred);
 366         if (!unconfined(profile)) {
 367                 struct inode *inode = file_inode(file);
 368                 struct path_cond cond = { inode->i_uid, inode->i_mode };
 369
 370                 error = aa_path_perm(OP_OPEN, profile, &file->f_path, 0,
 371                                      aa_map_file_to_perms(file), &cond);
 372                 /* todo cache full allowed permissions set and state */
 373                 fcxt->allow = aa_map_file_to_perms(file);
 374         }
 375
 376         return error;
 377 }
 378
 379 static int apparmor_file_alloc_security(struct file *file)
 380 {
 381         /* freed by apparmor_file_free_security */
 382         file->f_security = aa_alloc_file_context(GFP_KERNEL);
 383         if (!file->f_security)
 384                 return -ENOMEM;
 385         return 0;
 386
 387 }
 388
 389 static void apparmor_file_free_security(struct file *file)
 390 {
 391         struct aa_file_cxt *cxt = file->f_security;
 392
 393         aa_free_file_context(cxt);
 394 }
 395
 396 static int common_file_perm(int op, struct file *file, u32 mask)
 397 {
 398         struct aa_file_cxt *fcxt = file->f_security;
 399         struct aa_profile *profile, *fprofile = aa_cred_profile(file->f_cred);
 400         int error = 0;
 401
 402         BUG_ON(!fprofile);
 403
 404         if (!file->f_path.mnt ||
 405             !path_mediated_fs(file->f_path.dentry))
 406                 return 0;
 407
 408         profile = __aa_current_profile();
 409
 410         /* revalidate access, if task is unconfined, or the cached cred
 411          * doesn't match or if the request is for more permissions than
 412          * was granted.
 413          *
 414          * Note: the test for !unconfined(fprofile) is to handle file
 415          *       delegation from unconfined tasks
 416          */
 417         if (!unconfined(profile) && !unconfined(fprofile) &&
 418             ((fprofile != profile) || (mask & ~fcxt->allow)))
 419                 error = aa_file_perm(op, profile, file, mask);
 420
 421         return error;
 422 }
 423
 424 static int apparmor_file_permission(struct file *file, int mask)
 425 {
 426         return common_file_perm(OP_FPERM, file, mask);
 427 }
 428
 429 static int apparmor_file_lock(struct file *file, unsigned int cmd)
 430 {
 431         u32 mask = AA_MAY_LOCK;
 432
 433         if (cmd == F_WRLCK)
 434                 mask |= MAY_WRITE;
 435
 436         return common_file_perm(OP_FLOCK, file, mask);
 437 }
 438
 439 static int common_mmap(int op, struct file *file, unsigned long prot,
 440                        unsigned long flags)
 441 {
 442         int mask = 0;
 443
 444         if (!file || !file->f_security)
 445                 return 0;
 446
 447         if (prot & PROT_READ)
 448                 mask |= MAY_READ;
 449         /*
 450          * Private mappings don't require write perms since they don't
 451          * write back to the files
 452          */
 453         if ((prot & PROT_WRITE) && !(flags & MAP_PRIVATE))
 454                 mask |= MAY_WRITE;
 455         if (prot & PROT_EXEC)
 456                 mask |= AA_EXEC_MMAP;
 457
 458         return common_file_perm(op, file, mask);
 459 }
 460
 461 static int apparmor_mmap_file(struct file *file, unsigned long reqprot,
 462                               unsigned long prot, unsigned long flags)
 463 {
 464         return common_mmap(OP_FMMAP, file, prot, flags);
 465 }
 466
 467 static int apparmor_file_mprotect(struct vm_area_struct *vma,
 468                                   unsigned long reqprot, unsigned long prot)
 469 {
 470         return common_mmap(OP_FMPROT, vma->vm_file, prot,
 471                            !(vma->vm_flags & VM_SHARED) ? MAP_PRIVATE : 0);
 472 }
 473
 474 static int apparmor_getprocattr(struct task_struct *task, char *name,
 475                                 char **value)
 476 {
 477         int error = -ENOENT;
 478         /* released below */
 479         const struct cred *cred = get_task_cred(task);
 480         struct aa_task_cxt *cxt = cred_cxt(cred);
 481         struct aa_profile *profile = NULL;
 482
 483         if (strcmp(name, "current") == 0)
 484                 profile = aa_get_newest_profile(cxt->profile);
 485         else if (strcmp(name, "prev") == 0  && cxt->previous)
 486                 profile = aa_get_newest_profile(cxt->previous);
 487         else if (strcmp(name, "exec") == 0 && cxt->onexec)
 488                 profile = aa_get_newest_profile(cxt->onexec);
 489         else
 490                 error = -EINVAL;
 491
 492         if (profile)
 493                 error = aa_getprocattr(profile, value);
 494
 495         aa_put_profile(profile);
 496         put_cred(cred);
 497
 498         return error;
 499 }
 500
 501 static int apparmor_setprocattr(struct task_struct *task, char *name,
 502                                 void *value, size_t size)
 503 {
 504         struct common_audit_data sa;
 505         struct apparmor_audit_data aad = {0,};
 506         char *command, *largs = NULL, *args = value;
 507         size_t arg_size;
 508         int error;
 509
 510         if (size == 0)
 511                 return -EINVAL;
 512         /* task can only write its own attributes */
 513         if (current != task)
 514                 return -EACCES;
 515
 516         /* AppArmor requires that the buffer must be null terminated atm */
 517         if (args[size - 1] != '\0') {
 518                 /* null terminate */
 519                 largs = args = kmalloc(size + 1, GFP_KERNEL);
 520                 if (!args)
 521                         return -ENOMEM;
 522                 memcpy(args, value, size);
 523                 args[size] = '\0';
 524         }
 525
 526         error = -EINVAL;
 527         args = strim(args);
 528         command = strsep(&args, " ");
 529         if (!args)
 530                 goto out;
 531         args = skip_spaces(args);
 532         if (!*args)
 533                 goto out;
 534
 535         arg_size = size - (args - (largs ? largs : (char *) value));
 536         if (strcmp(name, "current") == 0) {
 537                 if (strcmp(command, "changehat") == 0) {
 538                         error = aa_setprocattr_changehat(args, arg_size,
 539                                                          !AA_DO_TEST);
 540                 } else if (strcmp(command, "permhat") == 0) {
 541                         error = aa_setprocattr_changehat(args, arg_size,
 542                                                          AA_DO_TEST);
 543                 } else if (strcmp(command, "changeprofile") == 0) {
 544                         error = aa_setprocattr_changeprofile(args, !AA_ONEXEC,
 545                                                              !AA_DO_TEST);
 546                 } else if (strcmp(command, "permprofile") == 0) {
 547                         error = aa_setprocattr_changeprofile(args, !AA_ONEXEC,
 548                                                              AA_DO_TEST);
 549                 } else
 550                         goto fail;
 551         } else if (strcmp(name, "exec") == 0) {
 552                 if (strcmp(command, "exec") == 0)
 553                         error = aa_setprocattr_changeprofile(args, AA_ONEXEC,
 554                                                              !AA_DO_TEST);
 555                 else
 556                         goto fail;
 557         } else
 558                 /* only support the "current" and "exec" process attributes */
 559                 goto fail;
 560
 561         if (!error)
 562                 error = size;
 563 out:
 564         kfree(largs);
 565         return error;
 566
 567 fail:
 568         sa.type = LSM_AUDIT_DATA_NONE;
 569         sa.aad = &aad;
 570         aad.profile = aa_current_profile();
 571         aad.op = OP_SETPROCATTR;
 572         aad.info = name;
 573         aad.error = error = -EINVAL;
 574         aa_audit_msg(AUDIT_APPARMOR_DENIED, &sa, NULL);
 575         goto out;
 576 }
 577
 578 static int apparmor_task_setrlimit(struct task_struct *task,
 579                 unsigned int resource, struct rlimit *new_rlim)
 580 {
 581         struct aa_profile *profile = __aa_current_profile();
 582         int error = 0;
 583
 584         if (!unconfined(profile))
 585                 error = aa_task_setrlimit(profile, task, resource, new_rlim);
 586
 587         return error;
 588 }
 589
 590 static struct security_hook_list apparmor_hooks[] = {
 591         LSM_HOOK_INIT(ptrace_access_check, apparmor_ptrace_access_check),
 592         LSM_HOOK_INIT(ptrace_traceme, apparmor_ptrace_traceme),
 593         LSM_HOOK_INIT(capget, apparmor_capget),
 594         LSM_HOOK_INIT(capable, apparmor_capable),
 595
 596         LSM_HOOK_INIT(path_link, apparmor_path_link),
 597         LSM_HOOK_INIT(path_unlink, apparmor_path_unlink),
 598         LSM_HOOK_INIT(path_symlink, apparmor_path_symlink),
 599         LSM_HOOK_INIT(path_mkdir, apparmor_path_mkdir),
 600         LSM_HOOK_INIT(path_rmdir, apparmor_path_rmdir),
 601         LSM_HOOK_INIT(path_mknod, apparmor_path_mknod),
 602         LSM_HOOK_INIT(path_rename, apparmor_path_rename),
 603         LSM_HOOK_INIT(path_chmod, apparmor_path_chmod),
 604         LSM_HOOK_INIT(path_chown, apparmor_path_chown),
 605         LSM_HOOK_INIT(path_truncate, apparmor_path_truncate),
 606         LSM_HOOK_INIT(inode_getattr, apparmor_inode_getattr),
 607
 608         LSM_HOOK_INIT(file_open, apparmor_file_open),
 609         LSM_HOOK_INIT(file_permission, apparmor_file_permission),
 610         LSM_HOOK_INIT(file_alloc_security, apparmor_file_alloc_security),
 611         LSM_HOOK_INIT(file_free_security, apparmor_file_free_security),
 612         LSM_HOOK_INIT(mmap_file, apparmor_mmap_file),
 613         LSM_HOOK_INIT(file_mprotect, apparmor_file_mprotect),
 614         LSM_HOOK_INIT(file_lock, apparmor_file_lock),
 615
 616         LSM_HOOK_INIT(getprocattr, apparmor_getprocattr),
 617         LSM_HOOK_INIT(setprocattr, apparmor_setprocattr),
 618
 619         LSM_HOOK_INIT(cred_alloc_blank, apparmor_cred_alloc_blank),
 620         LSM_HOOK_INIT(cred_free, apparmor_cred_free),
 621         LSM_HOOK_INIT(cred_prepare, apparmor_cred_prepare),
 622         LSM_HOOK_INIT(cred_transfer, apparmor_cred_transfer),
 623
 624         LSM_HOOK_INIT(bprm_set_creds, apparmor_bprm_set_creds),
 625         LSM_HOOK_INIT(bprm_committing_creds, apparmor_bprm_committing_creds),
 626         LSM_HOOK_INIT(bprm_committed_creds, apparmor_bprm_committed_creds),
 627         LSM_HOOK_INIT(bprm_secureexec, apparmor_bprm_secureexec),
 628
 629         LSM_HOOK_INIT(task_setrlimit, apparmor_task_setrlimit),
 630 };
 631
 632 /*
 633  * AppArmor sysfs module parameters
 634  */
 635
 636 static int param_set_aabool(const char *val, const struct kernel_param *kp);
 637 static int param_get_aabool(char *buffer, const struct kernel_param *kp);
 638 #define param_check_aabool param_check_bool
 639 static const struct kernel_param_ops param_ops_aabool = {
 640         .flags = KERNEL_PARAM_OPS_FL_NOARG,
 641         .set = param_set_aabool,
 642         .get = param_get_aabool
 643 };
 644
 645 static int param_set_aauint(const char *val, const struct kernel_param *kp);
 646 static int param_get_aauint(char *buffer, const struct kernel_param *kp);
 647 #define param_check_aauint param_check_uint
 648 static const struct kernel_param_ops param_ops_aauint = {
 649         .set = param_set_aauint,
 650         .get = param_get_aauint
 651 };
 652
 653 static int param_set_aalockpolicy(const char *val, const struct kernel_param *kp);
 654 static int param_get_aalockpolicy(char *buffer, const struct kernel_param *kp);
 655 #define param_check_aalockpolicy param_check_bool
 656 static const struct kernel_param_ops param_ops_aalockpolicy = {
 657         .flags = KERNEL_PARAM_OPS_FL_NOARG,
 658         .set = param_set_aalockpolicy,
 659         .get = param_get_aalockpolicy
 660 };
 661
 662 static int param_set_audit(const char *val, struct kernel_param *kp);
 663 static int param_get_audit(char *buffer, struct kernel_param *kp);
 664
 665 static int param_set_mode(const char *val, struct kernel_param *kp);
 666 static int param_get_mode(char *buffer, struct kernel_param *kp);
 667
 668 /* Flag values, also controllable via /sys/module/apparmor/parameters
 669  * We define special types as we want to do additional mediation.
 670  */
 671
 672 /* AppArmor global enforcement switch - complain, enforce, kill */
 673 enum profile_mode aa_g_profile_mode = APPARMOR_ENFORCE;
 674 module_param_call(mode, param_set_mode, param_get_mode,
 675                   &aa_g_profile_mode, S_IRUSR | S_IWUSR);
 676
 677 #ifdef CONFIG_SECURITY_APPARMOR_HASH
 678 /* whether policy verification hashing is enabled */
 679 bool aa_g_hash_policy = IS_ENABLED(CONFIG_SECURITY_APPARMOR_HASH_DEFAULT);
 680 module_param_named(hash_policy, aa_g_hash_policy, aabool, S_IRUSR | S_IWUSR);
 681 #endif
 682
 683 /* Debug mode */
 684 bool aa_g_debug = IS_ENABLED(CONFIG_SECURITY_DEBUG_MESSAGES);
 685 module_param_named(debug, aa_g_debug, aabool, S_IRUSR | S_IWUSR);
 686
 687 /* Audit mode */
 688 enum audit_mode aa_g_audit;
 689 module_param_call(audit, param_set_audit, param_get_audit,
 690                   &aa_g_audit, S_IRUSR | S_IWUSR);
 691
 692 /* Determines if audit header is included in audited messages.  This
 693  * provides more context if the audit daemon is not running
 694  */
 695 bool aa_g_audit_header = 1;
 696 module_param_named(audit_header, aa_g_audit_header, aabool,
 697                    S_IRUSR | S_IWUSR);
 698
 699 /* lock out loading/removal of policy
 700  * TODO: add in at boot loading of policy, which is the only way to
 701  *       load policy, if lock_policy is set
 702  */
 703 bool aa_g_lock_policy;
 704 module_param_named(lock_policy, aa_g_lock_policy, aalockpolicy,
 705                    S_IRUSR | S_IWUSR);
 706
 707 /* Syscall logging mode */
 708 bool aa_g_logsyscall;
 709 module_param_named(logsyscall, aa_g_logsyscall, aabool, S_IRUSR | S_IWUSR);
 710
 711 /* Maximum pathname length before accesses will start getting rejected */
 712 unsigned int aa_g_path_max = 2 * PATH_MAX;
 713 module_param_named(path_max, aa_g_path_max, aauint, S_IRUSR | S_IWUSR);
 714
 715 /* Determines how paranoid loading of policy is and how much verification
 716  * on the loaded policy is done.
 717  */
 718 bool aa_g_paranoid_load = 1;
 719 module_param_named(paranoid_load, aa_g_paranoid_load, aabool,
 720                    S_IRUSR | S_IWUSR);
 721
 722 /* Boot time disable flag */
 723 static bool apparmor_enabled = CONFIG_SECURITY_APPARMOR_BOOTPARAM_VALUE;
 724 module_param_named(enabled, apparmor_enabled, bool, S_IRUGO);
 725
 726 static int __init apparmor_enabled_setup(char *str)
 727 {
 728         unsigned long enabled;
 729         int error = kstrtoul(str, 0, &enabled);
 730         if (!error)
 731                 apparmor_enabled = enabled ? 1 : 0;
 732         return 1;
 733 }
 734
 735 __setup("apparmor=", apparmor_enabled_setup);
 736
 737 /* set global flag turning off the ability to load policy */
 738 static int param_set_aalockpolicy(const char *val, const struct kernel_param *kp)
 739 {
 740         if (!policy_admin_capable())
 741                 return -EPERM;
 742         return param_set_bool(val, kp);
 743 }
 744
 745 static int param_get_aalockpolicy(char *buffer, const struct kernel_param *kp)
 746 {
 747         if (!policy_view_capable())
 748                 return -EPERM;
 749         return param_get_bool(buffer, kp);
 750 }
 751
 752 static int param_set_aabool(const char *val, const struct kernel_param *kp)
 753 {
 754         if (!policy_admin_capable())
 755                 return -EPERM;
 756         return param_set_bool(val, kp);
 757 }
 758
 759 static int param_get_aabool(char *buffer, const struct kernel_param *kp)
 760 {
 761         if (!policy_view_capable())
 762                 return -EPERM;
 763         return param_get_bool(buffer, kp);
 764 }
 765
 766 static int param_set_aauint(const char *val, const struct kernel_param *kp)
 767 {
 768         if (!policy_admin_capable())
 769                 return -EPERM;
 770         return param_set_uint(val, kp);
 771 }
 772
 773 static int param_get_aauint(char *buffer, const struct kernel_param *kp)
 774 {
 775         if (!policy_view_capable())
 776                 return -EPERM;
 777         return param_get_uint(buffer, kp);
 778 }
 779
 780 static int param_get_audit(char *buffer, struct kernel_param *kp)
 781 {
 782         if (!policy_view_capable())
 783                 return -EPERM;
 784
 785         if (!apparmor_enabled)
 786                 return -EINVAL;
 787
 788         return sprintf(buffer, "%s", audit_mode_names[aa_g_audit]);
 789 }
 790
 791 static int param_set_audit(const char *val, struct kernel_param *kp)
 792 {
 793         int i;
 794         if (!policy_admin_capable())
 795                 return -EPERM;
 796
 797         if (!apparmor_enabled)
 798                 return -EINVAL;
 799
 800         if (!val)
 801                 return -EINVAL;
 802
 803         for (i = 0; i < AUDIT_MAX_INDEX; i++) {
 804                 if (strcmp(val, audit_mode_names[i]) == 0) {
 805                         aa_g_audit = i;
 806                         return 0;
 807                 }
 808         }
 809
 810         return -EINVAL;
 811 }
 812
 813 static int param_get_mode(char *buffer, struct kernel_param *kp)
 814 {
 815         if (!policy_admin_capable())
 816                 return -EPERM;
 817
 818         if (!apparmor_enabled)
 819                 return -EINVAL;
 820
 821         return sprintf(buffer, "%s", aa_profile_mode_names[aa_g_profile_mode]);
 822 }
 823
 824 static int param_set_mode(const char *val, struct kernel_param *kp)
 825 {
 826         int i;
 827         if (!policy_admin_capable())
 828                 return -EPERM;
 829
 830         if (!apparmor_enabled)
 831                 return -EINVAL;
 832
 833         if (!val)
 834                 return -EINVAL;
 835
 836         for (i = 0; i < APPARMOR_MODE_NAMES_MAX_INDEX; i++) {
 837                 if (strcmp(val, aa_profile_mode_names[i]) == 0) {
 838                         aa_g_profile_mode = i;
 839                         return 0;
 840                 }
 841         }
 842
 843         return -EINVAL;
 844 }
 845
 846 /*
 847  * AppArmor init functions
 848  */
 849
 850 /**
 851  * set_init_cxt - set a task context and profile on the first task.
 852  *
 853  * TODO: allow setting an alternate profile than unconfined
 854  */
 855 static int __init set_init_cxt(void)
 856 {
 857         struct cred *cred = (struct cred *)current->real_cred;
 858         struct aa_task_cxt *cxt;
 859
 860         cxt = aa_alloc_task_context(GFP_KERNEL);
 861         if (!cxt)
 862                 return -ENOMEM;
 863
 864         cxt->profile = aa_get_profile(root_ns->unconfined);
 865         cred_cxt(cred) = cxt;
 866
 867         return 0;
 868 }
 869
 870 static int __init apparmor_init(void)
 871 {
 872         int error;
 873
 874         if (!apparmor_enabled || !security_module_enable("apparmor")) {
 875                 aa_info_message("AppArmor disabled by boot time parameter");
 876                 apparmor_enabled = 0;
 877                 return 0;
 878         }
 879
 880         error = aa_alloc_root_ns();
 881         if (error) {
 882                 AA_ERROR("Unable to allocate default profile namespace\n");
 883                 goto alloc_out;
 884         }
 885
 886         error = set_init_cxt();
 887         if (error) {
 888                 AA_ERROR("Failed to set context on init task\n");
 889                 aa_free_root_ns();
 890                 goto alloc_out;
 891         }
 892         security_add_hooks(apparmor_hooks, ARRAY_SIZE(apparmor_hooks));
 893
 894         /* Report that AppArmor successfully initialized */
 895         apparmor_initialized = 1;
 896         if (aa_g_profile_mode == APPARMOR_COMPLAIN)
 897                 aa_info_message("AppArmor initialized: complain mode enabled");
 898         else if (aa_g_profile_mode == APPARMOR_KILL)
 899                 aa_info_message("AppArmor initialized: kill mode enabled");
 900         else
 901                 aa_info_message("AppArmor initialized");
 902
 903         return error;
 904
 905 alloc_out:
 906         aa_destroy_aafs();
 907
 908         apparmor_enabled = 0;
 909         return error;
 910 }
 911
 912 security_initcall(apparmor_init);