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