1 /* 2 * AppArmor security module 3 * 4 * This file contains AppArmor mediation of files 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/tty.h> 16 #include <linux/fdtable.h> 17 #include <linux/file.h> 18 19 #include "include/apparmor.h" 20 #include "include/audit.h" 21 #include "include/cred.h" 22 #include "include/file.h" 23 #include "include/match.h" 24 #include "include/net.h" 25 #include "include/path.h" 26 #include "include/policy.h" 27 #include "include/label.h" 28 29 static u32 map_mask_to_chr_mask(u32 mask) 30 { 31 u32 m = mask & PERMS_CHRS_MASK; 32 33 if (mask & AA_MAY_GETATTR) 34 m |= MAY_READ; 35 if (mask & (AA_MAY_SETATTR | AA_MAY_CHMOD | AA_MAY_CHOWN)) 36 m |= MAY_WRITE; 37 38 return m; 39 } 40 41 /** 42 * audit_file_mask - convert mask to permission string 43 * @buffer: buffer to write string to (NOT NULL) 44 * @mask: permission mask to convert 45 */ 46 static void audit_file_mask(struct audit_buffer *ab, u32 mask) 47 { 48 char str[10]; 49 50 aa_perm_mask_to_str(str, sizeof(str), aa_file_perm_chrs, 51 map_mask_to_chr_mask(mask)); 52 audit_log_string(ab, str); 53 } 54 55 /** 56 * file_audit_cb - call back for file specific audit fields 57 * @ab: audit_buffer (NOT NULL) 58 * @va: audit struct to audit values of (NOT NULL) 59 */ 60 static void file_audit_cb(struct audit_buffer *ab, void *va) 61 { 62 struct common_audit_data *sa = va; 63 kuid_t fsuid = current_fsuid(); 64 65 if (aad(sa)->request & AA_AUDIT_FILE_MASK) { 66 audit_log_format(ab, " requested_mask="); 67 audit_file_mask(ab, aad(sa)->request); 68 } 69 if (aad(sa)->denied & AA_AUDIT_FILE_MASK) { 70 audit_log_format(ab, " denied_mask="); 71 audit_file_mask(ab, aad(sa)->denied); 72 } 73 if (aad(sa)->request & AA_AUDIT_FILE_MASK) { 74 audit_log_format(ab, " fsuid=%d", 75 from_kuid(&init_user_ns, fsuid)); 76 audit_log_format(ab, " ouid=%d", 77 from_kuid(&init_user_ns, aad(sa)->fs.ouid)); 78 } 79 80 if (aad(sa)->peer) { 81 audit_log_format(ab, " target="); 82 aa_label_xaudit(ab, labels_ns(aad(sa)->label), aad(sa)->peer, 83 FLAG_VIEW_SUBNS, GFP_ATOMIC); 84 } else if (aad(sa)->fs.target) { 85 audit_log_format(ab, " target="); 86 audit_log_untrustedstring(ab, aad(sa)->fs.target); 87 } 88 } 89 90 /** 91 * aa_audit_file - handle the auditing of file operations 92 * @profile: the profile being enforced (NOT NULL) 93 * @perms: the permissions computed for the request (NOT NULL) 94 * @op: operation being mediated 95 * @request: permissions requested 96 * @name: name of object being mediated (MAYBE NULL) 97 * @target: name of target (MAYBE NULL) 98 * @tlabel: target label (MAY BE NULL) 99 * @ouid: object uid 100 * @info: extra information message (MAYBE NULL) 101 * @error: 0 if operation allowed else failure error code 102 * 103 * Returns: %0 or error on failure 104 */ 105 int aa_audit_file(struct aa_profile *profile, struct aa_perms *perms, 106 const char *op, u32 request, const char *name, 107 const char *target, struct aa_label *tlabel, 108 kuid_t ouid, const char *info, int error) 109 { 110 int type = AUDIT_APPARMOR_AUTO; 111 DEFINE_AUDIT_DATA(sa, LSM_AUDIT_DATA_TASK, op); 112 113 sa.u.tsk = NULL; 114 aad(&sa)->request = request; 115 aad(&sa)->name = name; 116 aad(&sa)->fs.target = target; 117 aad(&sa)->peer = tlabel; 118 aad(&sa)->fs.ouid = ouid; 119 aad(&sa)->info = info; 120 aad(&sa)->error = error; 121 sa.u.tsk = NULL; 122 123 if (likely(!aad(&sa)->error)) { 124 u32 mask = perms->audit; 125 126 if (unlikely(AUDIT_MODE(profile) == AUDIT_ALL)) 127 mask = 0xffff; 128 129 /* mask off perms that are not being force audited */ 130 aad(&sa)->request &= mask; 131 132 if (likely(!aad(&sa)->request)) 133 return 0; 134 type = AUDIT_APPARMOR_AUDIT; 135 } else { 136 /* only report permissions that were denied */ 137 aad(&sa)->request = aad(&sa)->request & ~perms->allow; 138 AA_BUG(!aad(&sa)->request); 139 140 if (aad(&sa)->request & perms->kill) 141 type = AUDIT_APPARMOR_KILL; 142 143 /* quiet known rejects, assumes quiet and kill do not overlap */ 144 if ((aad(&sa)->request & perms->quiet) && 145 AUDIT_MODE(profile) != AUDIT_NOQUIET && 146 AUDIT_MODE(profile) != AUDIT_ALL) 147 aad(&sa)->request &= ~perms->quiet; 148 149 if (!aad(&sa)->request) 150 return aad(&sa)->error; 151 } 152 153 aad(&sa)->denied = aad(&sa)->request & ~perms->allow; 154 return aa_audit(type, profile, &sa, file_audit_cb); 155 } 156 157 /** 158 * is_deleted - test if a file has been completely unlinked 159 * @dentry: dentry of file to test for deletion (NOT NULL) 160 * 161 * Returns: %1 if deleted else %0 162 */ 163 static inline bool is_deleted(struct dentry *dentry) 164 { 165 if (d_unlinked(dentry) && d_backing_inode(dentry)->i_nlink == 0) 166 return 1; 167 return 0; 168 } 169 170 static int path_name(const char *op, struct aa_label *label, 171 const struct path *path, int flags, char *buffer, 172 const char **name, struct path_cond *cond, u32 request) 173 { 174 struct aa_profile *profile; 175 const char *info = NULL; 176 int error; 177 178 error = aa_path_name(path, flags, buffer, name, &info, 179 labels_profile(label)->disconnected); 180 if (error) { 181 fn_for_each_confined(label, profile, 182 aa_audit_file(profile, &nullperms, op, request, *name, 183 NULL, NULL, cond->uid, info, error)); 184 return error; 185 } 186 187 return 0; 188 } 189 190 /** 191 * map_old_perms - map old file perms layout to the new layout 192 * @old: permission set in old mapping 193 * 194 * Returns: new permission mapping 195 */ 196 static u32 map_old_perms(u32 old) 197 { 198 u32 new = old & 0xf; 199 if (old & MAY_READ) 200 new |= AA_MAY_GETATTR | AA_MAY_OPEN; 201 if (old & MAY_WRITE) 202 new |= AA_MAY_SETATTR | AA_MAY_CREATE | AA_MAY_DELETE | 203 AA_MAY_CHMOD | AA_MAY_CHOWN | AA_MAY_OPEN; 204 if (old & 0x10) 205 new |= AA_MAY_LINK; 206 /* the old mapping lock and link_subset flags where overlaid 207 * and use was determined by part of a pair that they were in 208 */ 209 if (old & 0x20) 210 new |= AA_MAY_LOCK | AA_LINK_SUBSET; 211 if (old & 0x40) /* AA_EXEC_MMAP */ 212 new |= AA_EXEC_MMAP; 213 214 return new; 215 } 216 217 /** 218 * aa_compute_fperms - convert dfa compressed perms to internal perms 219 * @dfa: dfa to compute perms for (NOT NULL) 220 * @state: state in dfa 221 * @cond: conditions to consider (NOT NULL) 222 * 223 * TODO: convert from dfa + state to permission entry, do computation conversion 224 * at load time. 225 * 226 * Returns: computed permission set 227 */ 228 struct aa_perms aa_compute_fperms(struct aa_dfa *dfa, unsigned int state, 229 struct path_cond *cond) 230 { 231 /* FIXME: change over to new dfa format 232 * currently file perms are encoded in the dfa, new format 233 * splits the permissions from the dfa. This mapping can be 234 * done at profile load 235 */ 236 struct aa_perms perms = { }; 237 238 if (uid_eq(current_fsuid(), cond->uid)) { 239 perms.allow = map_old_perms(dfa_user_allow(dfa, state)); 240 perms.audit = map_old_perms(dfa_user_audit(dfa, state)); 241 perms.quiet = map_old_perms(dfa_user_quiet(dfa, state)); 242 perms.xindex = dfa_user_xindex(dfa, state); 243 } else { 244 perms.allow = map_old_perms(dfa_other_allow(dfa, state)); 245 perms.audit = map_old_perms(dfa_other_audit(dfa, state)); 246 perms.quiet = map_old_perms(dfa_other_quiet(dfa, state)); 247 perms.xindex = dfa_other_xindex(dfa, state); 248 } 249 perms.allow |= AA_MAY_GETATTR; 250 251 /* change_profile wasn't determined by ownership in old mapping */ 252 if (ACCEPT_TABLE(dfa)[state] & 0x80000000) 253 perms.allow |= AA_MAY_CHANGE_PROFILE; 254 if (ACCEPT_TABLE(dfa)[state] & 0x40000000) 255 perms.allow |= AA_MAY_ONEXEC; 256 257 return perms; 258 } 259 260 /** 261 * aa_str_perms - find permission that match @name 262 * @dfa: to match against (MAYBE NULL) 263 * @state: state to start matching in 264 * @name: string to match against dfa (NOT NULL) 265 * @cond: conditions to consider for permission set computation (NOT NULL) 266 * @perms: Returns - the permissions found when matching @name 267 * 268 * Returns: the final state in @dfa when beginning @start and walking @name 269 */ 270 unsigned int aa_str_perms(struct aa_dfa *dfa, unsigned int start, 271 const char *name, struct path_cond *cond, 272 struct aa_perms *perms) 273 { 274 unsigned int state; 275 state = aa_dfa_match(dfa, start, name); 276 *perms = aa_compute_fperms(dfa, state, cond); 277 278 return state; 279 } 280 281 int __aa_path_perm(const char *op, struct aa_profile *profile, const char *name, 282 u32 request, struct path_cond *cond, int flags, 283 struct aa_perms *perms) 284 { 285 int e = 0; 286 287 if (profile_unconfined(profile)) 288 return 0; 289 aa_str_perms(profile->file.dfa, profile->file.start, name, cond, perms); 290 if (request & ~perms->allow) 291 e = -EACCES; 292 return aa_audit_file(profile, perms, op, request, name, NULL, NULL, 293 cond->uid, NULL, e); 294 } 295 296 297 static int profile_path_perm(const char *op, struct aa_profile *profile, 298 const struct path *path, char *buffer, u32 request, 299 struct path_cond *cond, int flags, 300 struct aa_perms *perms) 301 { 302 const char *name; 303 int error; 304 305 if (profile_unconfined(profile)) 306 return 0; 307 308 error = path_name(op, &profile->label, path, 309 flags | profile->path_flags, buffer, &name, cond, 310 request); 311 if (error) 312 return error; 313 return __aa_path_perm(op, profile, name, request, cond, flags, 314 perms); 315 } 316 317 /** 318 * aa_path_perm - do permissions check & audit for @path 319 * @op: operation being checked 320 * @label: profile being enforced (NOT NULL) 321 * @path: path to check permissions of (NOT NULL) 322 * @flags: any additional path flags beyond what the profile specifies 323 * @request: requested permissions 324 * @cond: conditional info for this request (NOT NULL) 325 * 326 * Returns: %0 else error if access denied or other error 327 */ 328 int aa_path_perm(const char *op, struct aa_label *label, 329 const struct path *path, int flags, u32 request, 330 struct path_cond *cond) 331 { 332 struct aa_perms perms = {}; 333 struct aa_profile *profile; 334 char *buffer = NULL; 335 int error; 336 337 flags |= PATH_DELEGATE_DELETED | (S_ISDIR(cond->mode) ? PATH_IS_DIR : 338 0); 339 get_buffers(buffer); 340 error = fn_for_each_confined(label, profile, 341 profile_path_perm(op, profile, path, buffer, request, 342 cond, flags, &perms)); 343 344 put_buffers(buffer); 345 346 return error; 347 } 348 349 /** 350 * xindex_is_subset - helper for aa_path_link 351 * @link: link permission set 352 * @target: target permission set 353 * 354 * test target x permissions are equal OR a subset of link x permissions 355 * this is done as part of the subset test, where a hardlink must have 356 * a subset of permissions that the target has. 357 * 358 * Returns: %1 if subset else %0 359 */ 360 static inline bool xindex_is_subset(u32 link, u32 target) 361 { 362 if (((link & ~AA_X_UNSAFE) != (target & ~AA_X_UNSAFE)) || 363 ((link & AA_X_UNSAFE) && !(target & AA_X_UNSAFE))) 364 return 0; 365 366 return 1; 367 } 368 369 static int profile_path_link(struct aa_profile *profile, 370 const struct path *link, char *buffer, 371 const struct path *target, char *buffer2, 372 struct path_cond *cond) 373 { 374 const char *lname, *tname = NULL; 375 struct aa_perms lperms = {}, perms; 376 const char *info = NULL; 377 u32 request = AA_MAY_LINK; 378 unsigned int state; 379 int error; 380 381 error = path_name(OP_LINK, &profile->label, link, profile->path_flags, 382 buffer, &lname, cond, AA_MAY_LINK); 383 if (error) 384 goto audit; 385 386 /* buffer2 freed below, tname is pointer in buffer2 */ 387 error = path_name(OP_LINK, &profile->label, target, profile->path_flags, 388 buffer2, &tname, cond, AA_MAY_LINK); 389 if (error) 390 goto audit; 391 392 error = -EACCES; 393 /* aa_str_perms - handles the case of the dfa being NULL */ 394 state = aa_str_perms(profile->file.dfa, profile->file.start, lname, 395 cond, &lperms); 396 397 if (!(lperms.allow & AA_MAY_LINK)) 398 goto audit; 399 400 /* test to see if target can be paired with link */ 401 state = aa_dfa_null_transition(profile->file.dfa, state); 402 aa_str_perms(profile->file.dfa, state, tname, cond, &perms); 403 404 /* force audit/quiet masks for link are stored in the second entry 405 * in the link pair. 406 */ 407 lperms.audit = perms.audit; 408 lperms.quiet = perms.quiet; 409 lperms.kill = perms.kill; 410 411 if (!(perms.allow & AA_MAY_LINK)) { 412 info = "target restricted"; 413 lperms = perms; 414 goto audit; 415 } 416 417 /* done if link subset test is not required */ 418 if (!(perms.allow & AA_LINK_SUBSET)) 419 goto done_tests; 420 421 /* Do link perm subset test requiring allowed permission on link are 422 * a subset of the allowed permissions on target. 423 */ 424 aa_str_perms(profile->file.dfa, profile->file.start, tname, cond, 425 &perms); 426 427 /* AA_MAY_LINK is not considered in the subset test */ 428 request = lperms.allow & ~AA_MAY_LINK; 429 lperms.allow &= perms.allow | AA_MAY_LINK; 430 431 request |= AA_AUDIT_FILE_MASK & (lperms.allow & ~perms.allow); 432 if (request & ~lperms.allow) { 433 goto audit; 434 } else if ((lperms.allow & MAY_EXEC) && 435 !xindex_is_subset(lperms.xindex, perms.xindex)) { 436 lperms.allow &= ~MAY_EXEC; 437 request |= MAY_EXEC; 438 info = "link not subset of target"; 439 goto audit; 440 } 441 442 done_tests: 443 error = 0; 444 445 audit: 446 return aa_audit_file(profile, &lperms, OP_LINK, request, lname, tname, 447 NULL, cond->uid, info, error); 448 } 449 450 /** 451 * aa_path_link - Handle hard link permission check 452 * @label: the label being enforced (NOT NULL) 453 * @old_dentry: the target dentry (NOT NULL) 454 * @new_dir: directory the new link will be created in (NOT NULL) 455 * @new_dentry: the link being created (NOT NULL) 456 * 457 * Handle the permission test for a link & target pair. Permission 458 * is encoded as a pair where the link permission is determined 459 * first, and if allowed, the target is tested. The target test 460 * is done from the point of the link match (not start of DFA) 461 * making the target permission dependent on the link permission match. 462 * 463 * The subset test if required forces that permissions granted 464 * on link are a subset of the permission granted to target. 465 * 466 * Returns: %0 if allowed else error 467 */ 468 int aa_path_link(struct aa_label *label, struct dentry *old_dentry, 469 const struct path *new_dir, struct dentry *new_dentry) 470 { 471 struct path link = { .mnt = new_dir->mnt, .dentry = new_dentry }; 472 struct path target = { .mnt = new_dir->mnt, .dentry = old_dentry }; 473 struct path_cond cond = { 474 d_backing_inode(old_dentry)->i_uid, 475 d_backing_inode(old_dentry)->i_mode 476 }; 477 char *buffer = NULL, *buffer2 = NULL; 478 struct aa_profile *profile; 479 int error; 480 481 /* buffer freed below, lname is pointer in buffer */ 482 get_buffers(buffer, buffer2); 483 error = fn_for_each_confined(label, profile, 484 profile_path_link(profile, &link, buffer, &target, 485 buffer2, &cond)); 486 put_buffers(buffer, buffer2); 487 488 return error; 489 } 490 491 static void update_file_ctx(struct aa_file_ctx *fctx, struct aa_label *label, 492 u32 request) 493 { 494 struct aa_label *l, *old; 495 496 /* update caching of label on file_ctx */ 497 spin_lock(&fctx->lock); 498 old = rcu_dereference_protected(fctx->label, 499 spin_is_locked(&fctx->lock)); 500 l = aa_label_merge(old, label, GFP_ATOMIC); 501 if (l) { 502 if (l != old) { 503 rcu_assign_pointer(fctx->label, l); 504 aa_put_label(old); 505 } else 506 aa_put_label(l); 507 fctx->allow |= request; 508 } 509 spin_unlock(&fctx->lock); 510 } 511 512 static int __file_path_perm(const char *op, struct aa_label *label, 513 struct aa_label *flabel, struct file *file, 514 u32 request, u32 denied) 515 { 516 struct aa_profile *profile; 517 struct aa_perms perms = {}; 518 struct path_cond cond = { 519 .uid = file_inode(file)->i_uid, 520 .mode = file_inode(file)->i_mode 521 }; 522 char *buffer; 523 int flags, error; 524 525 /* revalidation due to label out of date. No revocation at this time */ 526 if (!denied && aa_label_is_subset(flabel, label)) 527 /* TODO: check for revocation on stale profiles */ 528 return 0; 529 530 flags = PATH_DELEGATE_DELETED | (S_ISDIR(cond.mode) ? PATH_IS_DIR : 0); 531 get_buffers(buffer); 532 533 /* check every profile in task label not in current cache */ 534 error = fn_for_each_not_in_set(flabel, label, profile, 535 profile_path_perm(op, profile, &file->f_path, buffer, 536 request, &cond, flags, &perms)); 537 if (denied && !error) { 538 /* 539 * check every profile in file label that was not tested 540 * in the initial check above. 541 * 542 * TODO: cache full perms so this only happens because of 543 * conditionals 544 * TODO: don't audit here 545 */ 546 if (label == flabel) 547 error = fn_for_each(label, profile, 548 profile_path_perm(op, profile, &file->f_path, 549 buffer, request, &cond, flags, 550 &perms)); 551 else 552 error = fn_for_each_not_in_set(label, flabel, profile, 553 profile_path_perm(op, profile, &file->f_path, 554 buffer, request, &cond, flags, 555 &perms)); 556 } 557 if (!error) 558 update_file_ctx(file_ctx(file), label, request); 559 560 put_buffers(buffer); 561 562 return error; 563 } 564 565 static int __file_sock_perm(const char *op, struct aa_label *label, 566 struct aa_label *flabel, struct file *file, 567 u32 request, u32 denied) 568 { 569 struct socket *sock = (struct socket *) file->private_data; 570 int error; 571 572 AA_BUG(!sock); 573 574 /* revalidation due to label out of date. No revocation at this time */ 575 if (!denied && aa_label_is_subset(flabel, label)) 576 return 0; 577 578 /* TODO: improve to skip profiles cached in flabel */ 579 error = aa_sock_file_perm(label, op, request, sock); 580 if (denied) { 581 /* TODO: improve to skip profiles checked above */ 582 /* check every profile in file label to is cached */ 583 last_error(error, aa_sock_file_perm(flabel, op, request, sock)); 584 } 585 if (!error) 586 update_file_ctx(file_ctx(file), label, request); 587 588 return error; 589 } 590 591 /** 592 * aa_file_perm - do permission revalidation check & audit for @file 593 * @op: operation being checked 594 * @label: label being enforced (NOT NULL) 595 * @file: file to revalidate access permissions on (NOT NULL) 596 * @request: requested permissions 597 * 598 * Returns: %0 if access allowed else error 599 */ 600 int aa_file_perm(const char *op, struct aa_label *label, struct file *file, 601 u32 request) 602 { 603 struct aa_file_ctx *fctx; 604 struct aa_label *flabel; 605 u32 denied; 606 int error = 0; 607 608 AA_BUG(!label); 609 AA_BUG(!file); 610 611 fctx = file_ctx(file); 612 613 rcu_read_lock(); 614 flabel = rcu_dereference(fctx->label); 615 AA_BUG(!flabel); 616 617 /* revalidate access, if task is unconfined, or the cached cred 618 * doesn't match or if the request is for more permissions than 619 * was granted. 620 * 621 * Note: the test for !unconfined(flabel) is to handle file 622 * delegation from unconfined tasks 623 */ 624 denied = request & ~fctx->allow; 625 if (unconfined(label) || unconfined(flabel) || 626 (!denied && aa_label_is_subset(flabel, label))) 627 goto done; 628 629 /* TODO: label cross check */ 630 631 if (file->f_path.mnt && path_mediated_fs(file->f_path.dentry)) 632 error = __file_path_perm(op, label, flabel, file, request, 633 denied); 634 635 else if (S_ISSOCK(file_inode(file)->i_mode)) 636 error = __file_sock_perm(op, label, flabel, file, request, 637 denied); 638 done: 639 rcu_read_unlock(); 640 641 return error; 642 } 643 644 static void revalidate_tty(struct aa_label *label) 645 { 646 struct tty_struct *tty; 647 int drop_tty = 0; 648 649 tty = get_current_tty(); 650 if (!tty) 651 return; 652 653 spin_lock(&tty->files_lock); 654 if (!list_empty(&tty->tty_files)) { 655 struct tty_file_private *file_priv; 656 struct file *file; 657 /* TODO: Revalidate access to controlling tty. */ 658 file_priv = list_first_entry(&tty->tty_files, 659 struct tty_file_private, list); 660 file = file_priv->file; 661 662 if (aa_file_perm(OP_INHERIT, label, file, MAY_READ | MAY_WRITE)) 663 drop_tty = 1; 664 } 665 spin_unlock(&tty->files_lock); 666 tty_kref_put(tty); 667 668 if (drop_tty) 669 no_tty(); 670 } 671 672 static int match_file(const void *p, struct file *file, unsigned int fd) 673 { 674 struct aa_label *label = (struct aa_label *)p; 675 676 if (aa_file_perm(OP_INHERIT, label, file, aa_map_file_to_perms(file))) 677 return fd + 1; 678 return 0; 679 } 680 681 682 /* based on selinux's flush_unauthorized_files */ 683 void aa_inherit_files(const struct cred *cred, struct files_struct *files) 684 { 685 struct aa_label *label = aa_get_newest_cred_label(cred); 686 struct file *devnull = NULL; 687 unsigned int n; 688 689 revalidate_tty(label); 690 691 /* Revalidate access to inherited open files. */ 692 n = iterate_fd(files, 0, match_file, label); 693 if (!n) /* none found? */ 694 goto out; 695 696 devnull = dentry_open(&aa_null, O_RDWR, cred); 697 if (IS_ERR(devnull)) 698 devnull = NULL; 699 /* replace all the matching ones with this */ 700 do { 701 replace_fd(n - 1, devnull, 0); 702 } while ((n = iterate_fd(files, n, match_file, label)) != 0); 703 if (devnull) 704 fput(devnull); 705 out: 706 aa_put_label(label); 707 } 708