security/apparmor/label.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /*
   3  * AppArmor security module
   4  *
   5  * This file contains AppArmor label definitions
   6  *
   7  * Copyright 2017 Canonical Ltd.
   8  */
   9
  10 #include <linux/audit.h>
  11 #include <linux/seq_file.h>
  12 #include <linux/sort.h>
  13
  14 #include "include/apparmor.h"
  15 #include "include/cred.h"
  16 #include "include/label.h"
  17 #include "include/policy.h"
  18 #include "include/secid.h"
  19
  20
  21 /*
  22  * the aa_label represents the set of profiles confining an object
  23  *
  24  * Labels maintain a reference count to the set of pointers they reference
  25  * Labels are ref counted by
  26  *   tasks and object via the security field/security context off the field
  27  *   code - will take a ref count on a label if it needs the label
  28  *          beyond what is possible with an rcu_read_lock.
  29  *   profiles - each profile is a label
  30  *   secids - a pinned secid will keep a refcount of the label it is
  31  *          referencing
  32  *   objects - inode, files, sockets, ...
  33  *
  34  * Labels are not ref counted by the label set, so they maybe removed and
  35  * freed when no longer in use.
  36  *
  37  */
  38
  39 #define PROXY_POISON 97
  40 #define LABEL_POISON 100
  41
  42 static void free_proxy(struct aa_proxy *proxy)
  43 {
  44         if (proxy) {
  45                 /* p->label will not updated any more as p is dead */
  46                 aa_put_label(rcu_dereference_protected(proxy->label, true));
  47                 memset(proxy, 0, sizeof(*proxy));
  48                 RCU_INIT_POINTER(proxy->label, (struct aa_label *)PROXY_POISON);
  49                 kfree(proxy);
  50         }
  51 }
  52
  53 void aa_proxy_kref(struct kref *kref)
  54 {
  55         struct aa_proxy *proxy = container_of(kref, struct aa_proxy, count);
  56
  57         free_proxy(proxy);
  58 }
  59
  60 struct aa_proxy *aa_alloc_proxy(struct aa_label *label, gfp_t gfp)
  61 {
  62         struct aa_proxy *new;
  63
  64         new = kzalloc(sizeof(struct aa_proxy), gfp);
  65         if (new) {
  66                 kref_init(&new->count);
  67                 rcu_assign_pointer(new->label, aa_get_label(label));
  68         }
  69         return new;
  70 }
  71
  72 /* requires profile list write lock held */
  73 void __aa_proxy_redirect(struct aa_label *orig, struct aa_label *new)
  74 {
  75         struct aa_label *tmp;
  76
  77         AA_BUG(!orig);
  78         AA_BUG(!new);
  79         lockdep_assert_held_write(&labels_set(orig)->lock);
  80
  81         tmp = rcu_dereference_protected(orig->proxy->label,
  82                                         &labels_ns(orig)->lock);
  83         rcu_assign_pointer(orig->proxy->label, aa_get_label(new));
  84         orig->flags |= FLAG_STALE;
  85         aa_put_label(tmp);
  86 }
  87
  88 static void __proxy_share(struct aa_label *old, struct aa_label *new)
  89 {
  90         struct aa_proxy *proxy = new->proxy;
  91
  92         new->proxy = aa_get_proxy(old->proxy);
  93         __aa_proxy_redirect(old, new);
  94         aa_put_proxy(proxy);
  95 }
  96
  97
  98 /**
  99  * ns_cmp - compare ns for label set ordering
 100  * @a: ns to compare (NOT NULL)
 101  * @b: ns to compare (NOT NULL)
 102  *
 103  * Returns: <0 if a < b
 104  *          ==0 if a == b
 105  *          >0  if a > b
 106  */
 107 static int ns_cmp(struct aa_ns *a, struct aa_ns *b)
 108 {
 109         int res;
 110
 111         AA_BUG(!a);
 112         AA_BUG(!b);
 113         AA_BUG(!a->base.hname);
 114         AA_BUG(!b->base.hname);
 115
 116         if (a == b)
 117                 return 0;
 118
 119         res = a->level - b->level;
 120         if (res)
 121                 return res;
 122
 123         return strcmp(a->base.hname, b->base.hname);
 124 }
 125
 126 /**
 127  * profile_cmp - profile comparison for set ordering
 128  * @a: profile to compare (NOT NULL)
 129  * @b: profile to compare (NOT NULL)
 130  *
 131  * Returns: <0  if a < b
 132  *          ==0 if a == b
 133  *          >0  if a > b
 134  */
 135 static int profile_cmp(struct aa_profile *a, struct aa_profile *b)
 136 {
 137         int res;
 138
 139         AA_BUG(!a);
 140         AA_BUG(!b);
 141         AA_BUG(!a->ns);
 142         AA_BUG(!b->ns);
 143         AA_BUG(!a->base.hname);
 144         AA_BUG(!b->base.hname);
 145
 146         if (a == b || a->base.hname == b->base.hname)
 147                 return 0;
 148         res = ns_cmp(a->ns, b->ns);
 149         if (res)
 150                 return res;
 151
 152         return strcmp(a->base.hname, b->base.hname);
 153 }
 154
 155 /**
 156  * vec_cmp - label comparison for set ordering
 157  * @a: label to compare (NOT NULL)
 158  * @vec: vector of profiles to compare (NOT NULL)
 159  * @n: length of @vec
 160  *
 161  * Returns: <0  if a < vec
 162  *          ==0 if a == vec
 163  *          >0  if a > vec
 164  */
 165 static int vec_cmp(struct aa_profile **a, int an, struct aa_profile **b, int bn)
 166 {
 167         int i;
 168
 169         AA_BUG(!a);
 170         AA_BUG(!*a);
 171         AA_BUG(!b);
 172         AA_BUG(!*b);
 173         AA_BUG(an <= 0);
 174         AA_BUG(bn <= 0);
 175
 176         for (i = 0; i < an && i < bn; i++) {
 177                 int res = profile_cmp(a[i], b[i]);
 178
 179                 if (res != 0)
 180                         return res;
 181         }
 182
 183         return an - bn;
 184 }
 185
 186 static bool vec_is_stale(struct aa_profile **vec, int n)
 187 {
 188         int i;
 189
 190         AA_BUG(!vec);
 191
 192         for (i = 0; i < n; i++) {
 193                 if (profile_is_stale(vec[i]))
 194                         return true;
 195         }
 196
 197         return false;
 198 }
 199
 200 static bool vec_unconfined(struct aa_profile **vec, int n)
 201 {
 202         int i;
 203
 204         AA_BUG(!vec);
 205
 206         for (i = 0; i < n; i++) {
 207                 if (!profile_unconfined(vec[i]))
 208                         return false;
 209         }
 210
 211         return true;
 212 }
 213
 214 static int sort_cmp(const void *a, const void *b)
 215 {
 216         return profile_cmp(*(struct aa_profile **)a, *(struct aa_profile **)b);
 217 }
 218
 219 /*
 220  * assumes vec is sorted
 221  * Assumes @vec has null terminator at vec[n], and will null terminate
 222  * vec[n - dups]
 223  */
 224 static inline int unique(struct aa_profile **vec, int n)
 225 {
 226         int i, pos, dups = 0;
 227
 228         AA_BUG(n < 1);
 229         AA_BUG(!vec);
 230
 231         pos = 0;
 232         for (i = 1; i < n; i++) {
 233                 int res = profile_cmp(vec[pos], vec[i]);
 234
 235                 AA_BUG(res > 0, "vec not sorted");
 236                 if (res == 0) {
 237                         /* drop duplicate */
 238                         aa_put_profile(vec[i]);
 239                         dups++;
 240                         continue;
 241                 }
 242                 pos++;
 243                 if (dups)
 244                         vec[pos] = vec[i];
 245         }
 246
 247         AA_BUG(dups < 0);
 248
 249         return dups;
 250 }
 251
 252 /**
 253  * aa_vec_unique - canonical sort and unique a list of profiles
 254  * @n: number of refcounted profiles in the list (@n > 0)
 255  * @vec: list of profiles to sort and merge
 256  *
 257  * Returns: the number of duplicates eliminated == references put
 258  *
 259  * If @flags & VEC_FLAG_TERMINATE @vec has null terminator at vec[n], and will
 260  * null terminate vec[n - dups]
 261  */
 262 int aa_vec_unique(struct aa_profile **vec, int n, int flags)
 263 {
 264         int i, dups = 0;
 265
 266         AA_BUG(n < 1);
 267         AA_BUG(!vec);
 268
 269         /* vecs are usually small and inorder, have a fallback for larger */
 270         if (n > 8) {
 271                 sort(vec, n, sizeof(struct aa_profile *), sort_cmp, NULL);
 272                 dups = unique(vec, n);
 273                 goto out;
 274         }
 275
 276         /* insertion sort + unique in one */
 277         for (i = 1; i < n; i++) {
 278                 struct aa_profile *tmp = vec[i];
 279                 int pos, j;
 280
 281                 for (pos = i - 1 - dups; pos >= 0; pos--) {
 282                         int res = profile_cmp(vec[pos], tmp);
 283
 284                         if (res == 0) {
 285                                 /* drop duplicate entry */
 286                                 aa_put_profile(tmp);
 287                                 dups++;
 288                                 goto continue_outer;
 289                         } else if (res < 0)
 290                                 break;
 291                 }
 292                 /* pos is at entry < tmp, or index -1. Set to insert pos */
 293                 pos++;
 294
 295                 for (j = i - dups; j > pos; j--)
 296                         vec[j] = vec[j - 1];
 297                 vec[pos] = tmp;
 298 continue_outer:
 299                 ;
 300         }
 301
 302         AA_BUG(dups < 0);
 303
 304 out:
 305         if (flags & VEC_FLAG_TERMINATE)
 306                 vec[n - dups] = NULL;
 307
 308         return dups;
 309 }
 310
 311
 312 static void label_destroy(struct aa_label *label)
 313 {
 314         struct aa_label *tmp;
 315
 316         AA_BUG(!label);
 317
 318         if (!label_isprofile(label)) {
 319                 struct aa_profile *profile;
 320                 struct label_it i;
 321
 322                 aa_put_str(label->hname);
 323
 324                 label_for_each(i, label, profile) {
 325                         aa_put_profile(profile);
 326                         label->vec[i.i] = (struct aa_profile *)
 327                                            (LABEL_POISON + (long) i.i);
 328                 }
 329         }
 330
 331         if (rcu_dereference_protected(label->proxy->label, true) == label)
 332                 rcu_assign_pointer(label->proxy->label, NULL);
 333
 334         aa_free_secid(label->secid);
 335
 336         tmp = rcu_dereference_protected(label->proxy->label, true);
 337         if (tmp == label)
 338                 rcu_assign_pointer(label->proxy->label, NULL);
 339
 340         aa_put_proxy(label->proxy);
 341         label->proxy = (struct aa_proxy *) PROXY_POISON + 1;
 342 }
 343
 344 void aa_label_free(struct aa_label *label)
 345 {
 346         if (!label)
 347                 return;
 348
 349         label_destroy(label);
 350         kfree(label);
 351 }
 352
 353 static void label_free_switch(struct aa_label *label)
 354 {
 355         if (label->flags & FLAG_NS_COUNT)
 356                 aa_free_ns(labels_ns(label));
 357         else if (label_isprofile(label))
 358                 aa_free_profile(labels_profile(label));
 359         else
 360                 aa_label_free(label);
 361 }
 362
 363 static void label_free_rcu(struct rcu_head *head)
 364 {
 365         struct aa_label *label = container_of(head, struct aa_label, rcu);
 366
 367         if (label->flags & FLAG_IN_TREE)
 368                 (void) aa_label_remove(label);
 369         label_free_switch(label);
 370 }
 371
 372 void aa_label_kref(struct kref *kref)
 373 {
 374         struct aa_label *label = container_of(kref, struct aa_label, count);
 375         struct aa_ns *ns = labels_ns(label);
 376
 377         if (!ns) {
 378                 /* never live, no rcu callback needed, just using the fn */
 379                 label_free_switch(label);
 380                 return;
 381         }
 382         /* TODO: update labels_profile macro so it works here */
 383         AA_BUG(label_isprofile(label) &&
 384                on_list_rcu(&label->vec[0]->base.profiles));
 385         AA_BUG(label_isprofile(label) &&
 386                on_list_rcu(&label->vec[0]->base.list));
 387
 388         /* TODO: if compound label and not stale add to reclaim cache */
 389         call_rcu(&label->rcu, label_free_rcu);
 390 }
 391
 392 static void label_free_or_put_new(struct aa_label *label, struct aa_label *new)
 393 {
 394         if (label != new)
 395                 /* need to free directly to break circular ref with proxy */
 396                 aa_label_free(new);
 397         else
 398                 aa_put_label(new);
 399 }
 400
 401 bool aa_label_init(struct aa_label *label, int size, gfp_t gfp)
 402 {
 403         AA_BUG(!label);
 404         AA_BUG(size < 1);
 405
 406         if (aa_alloc_secid(label, gfp) < 0)
 407                 return false;
 408
 409         label->size = size;                     /* doesn't include null */
 410         label->vec[size] = NULL;                /* null terminate */
 411         kref_init(&label->count);
 412         RB_CLEAR_NODE(&label->node);
 413
 414         return true;
 415 }
 416
 417 /**
 418  * aa_label_alloc - allocate a label with a profile vector of @size length
 419  * @size: size of profile vector in the label
 420  * @proxy: proxy to use OR null if to allocate a new one
 421  * @gfp: memory allocation type
 422  *
 423  * Returns: new label
 424  *     else NULL if failed
 425  */
 426 struct aa_label *aa_label_alloc(int size, struct aa_proxy *proxy, gfp_t gfp)
 427 {
 428         struct aa_label *new;
 429
 430         AA_BUG(size < 1);
 431
 432         /*  + 1 for null terminator entry on vec */
 433         new = kzalloc(sizeof(*new) + sizeof(struct aa_profile *) * (size + 1),
 434                         gfp);
 435         AA_DEBUG("%s (%p)\n", __func__, new);
 436         if (!new)
 437                 goto fail;
 438
 439         if (!aa_label_init(new, size, gfp))
 440                 goto fail;
 441
 442         if (!proxy) {
 443                 proxy = aa_alloc_proxy(new, gfp);
 444                 if (!proxy)
 445                         goto fail;
 446         } else
 447                 aa_get_proxy(proxy);
 448         /* just set new's proxy, don't redirect proxy here if it was passed in*/
 449         new->proxy = proxy;
 450
 451         return new;
 452
 453 fail:
 454         kfree(new);
 455
 456         return NULL;
 457 }
 458
 459
 460 /**
 461  * label_cmp - label comparison for set ordering
 462  * @a: label to compare (NOT NULL)
 463  * @b: label to compare (NOT NULL)
 464  *
 465  * Returns: <0  if a < b
 466  *          ==0 if a == b
 467  *          >0  if a > b
 468  */
 469 static int label_cmp(struct aa_label *a, struct aa_label *b)
 470 {
 471         AA_BUG(!b);
 472
 473         if (a == b)
 474                 return 0;
 475
 476         return vec_cmp(a->vec, a->size, b->vec, b->size);
 477 }
 478
 479 /* helper fn for label_for_each_confined */
 480 int aa_label_next_confined(struct aa_label *label, int i)
 481 {
 482         AA_BUG(!label);
 483         AA_BUG(i < 0);
 484
 485         for (; i < label->size; i++) {
 486                 if (!profile_unconfined(label->vec[i]))
 487                         return i;
 488         }
 489
 490         return i;
 491 }
 492
 493 /**
 494  * aa_label_next_not_in_set - return the next profile of @sub not in @set
 495  * @I: label iterator
 496  * @set: label to test against
 497  * @sub: label to if is subset of @set
 498  *
 499  * Returns: profile in @sub that is not in @set, with iterator set pos after
 500  *     else NULL if @sub is a subset of @set
 501  */
 502 struct aa_profile *__aa_label_next_not_in_set(struct label_it *I,
 503                                               struct aa_label *set,
 504                                               struct aa_label *sub)
 505 {
 506         AA_BUG(!set);
 507         AA_BUG(!I);
 508         AA_BUG(I->i < 0);
 509         AA_BUG(I->i > set->size);
 510         AA_BUG(!sub);
 511         AA_BUG(I->j < 0);
 512         AA_BUG(I->j > sub->size);
 513
 514         while (I->j < sub->size && I->i < set->size) {
 515                 int res = profile_cmp(sub->vec[I->j], set->vec[I->i]);
 516
 517                 if (res == 0) {
 518                         (I->j)++;
 519                         (I->i)++;
 520                 } else if (res > 0)
 521                         (I->i)++;
 522                 else
 523                         return sub->vec[(I->j)++];
 524         }
 525
 526         if (I->j < sub->size)
 527                 return sub->vec[(I->j)++];
 528
 529         return NULL;
 530 }
 531
 532 /**
 533  * aa_label_is_subset - test if @sub is a subset of @set
 534  * @set: label to test against
 535  * @sub: label to test if is subset of @set
 536  *
 537  * Returns: true if @sub is subset of @set
 538  *     else false
 539  */
 540 bool aa_label_is_subset(struct aa_label *set, struct aa_label *sub)
 541 {
 542         struct label_it i = { };
 543
 544         AA_BUG(!set);
 545         AA_BUG(!sub);
 546
 547         if (sub == set)
 548                 return true;
 549
 550         return __aa_label_next_not_in_set(&i, set, sub) == NULL;
 551 }
 552
 553 /**
 554  * aa_label_is_unconfined_subset - test if @sub is a subset of @set
 555  * @set: label to test against
 556  * @sub: label to test if is subset of @set
 557  *
 558  * This checks for subset but taking into account unconfined. IF
 559  * @sub contains an unconfined profile that does not have a matching
 560  * unconfined in @set then this will not cause the test to fail.
 561  * Conversely we don't care about an unconfined in @set that is not in
 562  * @sub
 563  *
 564  * Returns: true if @sub is special_subset of @set
 565  *     else false
 566  */
 567 bool aa_label_is_unconfined_subset(struct aa_label *set, struct aa_label *sub)
 568 {
 569         struct label_it i = { };
 570         struct aa_profile *p;
 571
 572         AA_BUG(!set);
 573         AA_BUG(!sub);
 574
 575         if (sub == set)
 576                 return true;
 577
 578         do {
 579                 p = __aa_label_next_not_in_set(&i, set, sub);
 580                 if (p && !profile_unconfined(p))
 581                         break;
 582         } while (p);
 583
 584         return p == NULL;
 585 }
 586
 587
 588 /**
 589  * __label_remove - remove @label from the label set
 590  * @l: label to remove
 591  * @new: label to redirect to
 592  *
 593  * Requires: labels_set(@label)->lock write_lock
 594  * Returns:  true if the label was in the tree and removed
 595  */
 596 static bool __label_remove(struct aa_label *label, struct aa_label *new)
 597 {
 598         struct aa_labelset *ls = labels_set(label);
 599
 600         AA_BUG(!ls);
 601         AA_BUG(!label);
 602         lockdep_assert_held_write(&ls->lock);
 603
 604         if (new)
 605                 __aa_proxy_redirect(label, new);
 606
 607         if (!label_is_stale(label))
 608                 __label_make_stale(label);
 609
 610         if (label->flags & FLAG_IN_TREE) {
 611                 rb_erase(&label->node, &ls->root);
 612                 label->flags &= ~FLAG_IN_TREE;
 613                 return true;
 614         }
 615
 616         return false;
 617 }
 618
 619 /**
 620  * __label_replace - replace @old with @new in label set
 621  * @old: label to remove from label set
 622  * @new: label to replace @old with
 623  *
 624  * Requires: labels_set(@old)->lock write_lock
 625  *           valid ref count be held on @new
 626  * Returns: true if @old was in set and replaced by @new
 627  *
 628  * Note: current implementation requires label set be order in such a way
 629  *       that @new directly replaces @old position in the set (ie.
 630  *       using pointer comparison of the label address would not work)
 631  */
 632 static bool __label_replace(struct aa_label *old, struct aa_label *new)
 633 {
 634         struct aa_labelset *ls = labels_set(old);
 635
 636         AA_BUG(!ls);
 637         AA_BUG(!old);
 638         AA_BUG(!new);
 639         lockdep_assert_held_write(&ls->lock);
 640         AA_BUG(new->flags & FLAG_IN_TREE);
 641
 642         if (!label_is_stale(old))
 643                 __label_make_stale(old);
 644
 645         if (old->flags & FLAG_IN_TREE) {
 646                 rb_replace_node(&old->node, &new->node, &ls->root);
 647                 old->flags &= ~FLAG_IN_TREE;
 648                 new->flags |= FLAG_IN_TREE;
 649                 return true;
 650         }
 651
 652         return false;
 653 }
 654
 655 /**
 656  * __label_insert - attempt to insert @l into a label set
 657  * @ls: set of labels to insert @l into (NOT NULL)
 658  * @label: new label to insert (NOT NULL)
 659  * @replace: whether insertion should replace existing entry that is not stale
 660  *
 661  * Requires: @ls->lock
 662  *           caller to hold a valid ref on l
 663  *           if @replace is true l has a preallocated proxy associated
 664  * Returns: @l if successful in inserting @l - with additional refcount
 665  *          else ref counted equivalent label that is already in the set,
 666  *          the else condition only happens if @replace is false
 667  */
 668 static struct aa_label *__label_insert(struct aa_labelset *ls,
 669                                        struct aa_label *label, bool replace)
 670 {
 671         struct rb_node **new, *parent = NULL;
 672
 673         AA_BUG(!ls);
 674         AA_BUG(!label);
 675         AA_BUG(labels_set(label) != ls);
 676         lockdep_assert_held_write(&ls->lock);
 677         AA_BUG(label->flags & FLAG_IN_TREE);
 678
 679         /* Figure out where to put new node */
 680         new = &ls->root.rb_node;
 681         while (*new) {
 682                 struct aa_label *this = rb_entry(*new, struct aa_label, node);
 683                 int result = label_cmp(label, this);
 684
 685                 parent = *new;
 686                 if (result == 0) {
 687                         /* !__aa_get_label means queued for destruction,
 688                          * so replace in place, however the label has
 689                          * died before the replacement so do not share
 690                          * the proxy
 691                          */
 692                         if (!replace && !label_is_stale(this)) {
 693                                 if (__aa_get_label(this))
 694                                         return this;
 695                         } else
 696                                 __proxy_share(this, label);
 697                         AA_BUG(!__label_replace(this, label));
 698                         return aa_get_label(label);
 699                 } else if (result < 0)
 700                         new = &((*new)->rb_left);
 701                 else /* (result > 0) */
 702                         new = &((*new)->rb_right);
 703         }
 704
 705         /* Add new node and rebalance tree. */
 706         rb_link_node(&label->node, parent, new);
 707         rb_insert_color(&label->node, &ls->root);
 708         label->flags |= FLAG_IN_TREE;
 709
 710         return aa_get_label(label);
 711 }
 712
 713 /**
 714  * __vec_find - find label that matches @vec in label set
 715  * @vec: vec of profiles to find matching label for (NOT NULL)
 716  * @n: length of @vec
 717  *
 718  * Requires: @vec_labelset(vec) lock held
 719  *           caller to hold a valid ref on l
 720  *
 721  * Returns: ref counted @label if matching label is in tree
 722  *          ref counted label that is equiv to @l in tree
 723  *     else NULL if @vec equiv is not in tree
 724  */
 725 static struct aa_label *__vec_find(struct aa_profile **vec, int n)
 726 {
 727         struct rb_node *node;
 728
 729         AA_BUG(!vec);
 730         AA_BUG(!*vec);
 731         AA_BUG(n <= 0);
 732
 733         node = vec_labelset(vec, n)->root.rb_node;
 734         while (node) {
 735                 struct aa_label *this = rb_entry(node, struct aa_label, node);
 736                 int result = vec_cmp(this->vec, this->size, vec, n);
 737
 738                 if (result > 0)
 739                         node = node->rb_left;
 740                 else if (result < 0)
 741                         node = node->rb_right;
 742                 else
 743                         return __aa_get_label(this);
 744         }
 745
 746         return NULL;
 747 }
 748
 749 /**
 750  * __label_find - find label @label in label set
 751  * @label: label to find (NOT NULL)
 752  *
 753  * Requires: labels_set(@label)->lock held
 754  *           caller to hold a valid ref on l
 755  *
 756  * Returns: ref counted @label if @label is in tree OR
 757  *          ref counted label that is equiv to @label in tree
 758  *     else NULL if @label or equiv is not in tree
 759  */
 760 static struct aa_label *__label_find(struct aa_label *label)
 761 {
 762         AA_BUG(!label);
 763
 764         return __vec_find(label->vec, label->size);
 765 }
 766
 767
 768 /**
 769  * aa_label_remove - remove a label from the labelset
 770  * @label: label to remove
 771  *
 772  * Returns: true if @label was removed from the tree
 773  *     else @label was not in tree so it could not be removed
 774  */
 775 bool aa_label_remove(struct aa_label *label)
 776 {
 777         struct aa_labelset *ls = labels_set(label);
 778         unsigned long flags;
 779         bool res;
 780
 781         AA_BUG(!ls);
 782
 783         write_lock_irqsave(&ls->lock, flags);
 784         res = __label_remove(label, ns_unconfined(labels_ns(label)));
 785         write_unlock_irqrestore(&ls->lock, flags);
 786
 787         return res;
 788 }
 789
 790 /**
 791  * aa_label_replace - replace a label @old with a new version @new
 792  * @old: label to replace
 793  * @new: label replacing @old
 794  *
 795  * Returns: true if @old was in tree and replaced
 796  *     else @old was not in tree, and @new was not inserted
 797  */
 798 bool aa_label_replace(struct aa_label *old, struct aa_label *new)
 799 {
 800         unsigned long flags;
 801         bool res;
 802
 803         if (name_is_shared(old, new) && labels_ns(old) == labels_ns(new)) {
 804                 write_lock_irqsave(&labels_set(old)->lock, flags);
 805                 if (old->proxy != new->proxy)
 806                         __proxy_share(old, new);
 807                 else
 808                         __aa_proxy_redirect(old, new);
 809                 res = __label_replace(old, new);
 810                 write_unlock_irqrestore(&labels_set(old)->lock, flags);
 811         } else {
 812                 struct aa_label *l;
 813                 struct aa_labelset *ls = labels_set(old);
 814
 815                 write_lock_irqsave(&ls->lock, flags);
 816                 res = __label_remove(old, new);
 817                 if (labels_ns(old) != labels_ns(new)) {
 818                         write_unlock_irqrestore(&ls->lock, flags);
 819                         ls = labels_set(new);
 820                         write_lock_irqsave(&ls->lock, flags);
 821                 }
 822                 l = __label_insert(ls, new, true);
 823                 res = (l == new);
 824                 write_unlock_irqrestore(&ls->lock, flags);
 825                 aa_put_label(l);
 826         }
 827
 828         return res;
 829 }
 830
 831 /**
 832  * vec_find - find label @l in label set
 833  * @vec: array of profiles to find equiv label for (NOT NULL)
 834  * @n: length of @vec
 835  *
 836  * Returns: refcounted label if @vec equiv is in tree
 837  *     else NULL if @vec equiv is not in tree
 838  */
 839 static struct aa_label *vec_find(struct aa_profile **vec, int n)
 840 {
 841         struct aa_labelset *ls;
 842         struct aa_label *label;
 843         unsigned long flags;
 844
 845         AA_BUG(!vec);
 846         AA_BUG(!*vec);
 847         AA_BUG(n <= 0);
 848
 849         ls = vec_labelset(vec, n);
 850         read_lock_irqsave(&ls->lock, flags);
 851         label = __vec_find(vec, n);
 852         read_unlock_irqrestore(&ls->lock, flags);
 853
 854         return label;
 855 }
 856
 857 /* requires sort and merge done first */
 858 static struct aa_label *vec_create_and_insert_label(struct aa_profile **vec,
 859                                                     int len, gfp_t gfp)
 860 {
 861         struct aa_label *label = NULL;
 862         struct aa_labelset *ls;
 863         unsigned long flags;
 864         struct aa_label *new;
 865         int i;
 866
 867         AA_BUG(!vec);
 868
 869         if (len == 1)
 870                 return aa_get_label(&vec[0]->label);
 871
 872         ls = labels_set(&vec[len - 1]->label);
 873
 874         /* TODO: enable when read side is lockless
 875          * check if label exists before taking locks
 876          */
 877         new = aa_label_alloc(len, NULL, gfp);
 878         if (!new)
 879                 return NULL;
 880
 881         for (i = 0; i < len; i++)
 882                 new->vec[i] = aa_get_profile(vec[i]);
 883
 884         write_lock_irqsave(&ls->lock, flags);
 885         label = __label_insert(ls, new, false);
 886         write_unlock_irqrestore(&ls->lock, flags);
 887         label_free_or_put_new(label, new);
 888
 889         return label;
 890 }
 891
 892 struct aa_label *aa_vec_find_or_create_label(struct aa_profile **vec, int len,
 893                                              gfp_t gfp)
 894 {
 895         struct aa_label *label = vec_find(vec, len);
 896
 897         if (label)
 898                 return label;
 899
 900         return vec_create_and_insert_label(vec, len, gfp);
 901 }
 902
 903 /**
 904  * aa_label_find - find label @label in label set
 905  * @label: label to find (NOT NULL)
 906  *
 907  * Requires: caller to hold a valid ref on l
 908  *
 909  * Returns: refcounted @label if @label is in tree
 910  *          refcounted label that is equiv to @label in tree
 911  *     else NULL if @label or equiv is not in tree
 912  */
 913 struct aa_label *aa_label_find(struct aa_label *label)
 914 {
 915         AA_BUG(!label);
 916
 917         return vec_find(label->vec, label->size);
 918 }
 919
 920
 921 /**
 922  * aa_label_insert - insert label @label into @ls or return existing label
 923  * @ls - labelset to insert @label into
 924  * @label - label to insert
 925  *
 926  * Requires: caller to hold a valid ref on @label
 927  *
 928  * Returns: ref counted @label if successful in inserting @label
 929  *     else ref counted equivalent label that is already in the set
 930  */
 931 struct aa_label *aa_label_insert(struct aa_labelset *ls, struct aa_label *label)
 932 {
 933         struct aa_label *l;
 934         unsigned long flags;
 935
 936         AA_BUG(!ls);
 937         AA_BUG(!label);
 938
 939         /* check if label exists before taking lock */
 940         if (!label_is_stale(label)) {
 941                 read_lock_irqsave(&ls->lock, flags);
 942                 l = __label_find(label);
 943                 read_unlock_irqrestore(&ls->lock, flags);
 944                 if (l)
 945                         return l;
 946         }
 947
 948         write_lock_irqsave(&ls->lock, flags);
 949         l = __label_insert(ls, label, false);
 950         write_unlock_irqrestore(&ls->lock, flags);
 951
 952         return l;
 953 }
 954
 955
 956 /**
 957  * aa_label_next_in_merge - find the next profile when merging @a and @b
 958  * @I: label iterator
 959  * @a: label to merge
 960  * @b: label to merge
 961  *
 962  * Returns: next profile
 963  *     else null if no more profiles
 964  */
 965 struct aa_profile *aa_label_next_in_merge(struct label_it *I,
 966                                           struct aa_label *a,
 967                                           struct aa_label *b)
 968 {
 969         AA_BUG(!a);
 970         AA_BUG(!b);
 971         AA_BUG(!I);
 972         AA_BUG(I->i < 0);
 973         AA_BUG(I->i > a->size);
 974         AA_BUG(I->j < 0);
 975         AA_BUG(I->j > b->size);
 976
 977         if (I->i < a->size) {
 978                 if (I->j < b->size) {
 979                         int res = profile_cmp(a->vec[I->i], b->vec[I->j]);
 980
 981                         if (res > 0)
 982                                 return b->vec[(I->j)++];
 983                         if (res == 0)
 984                                 (I->j)++;
 985                 }
 986
 987                 return a->vec[(I->i)++];
 988         }
 989
 990         if (I->j < b->size)
 991                 return b->vec[(I->j)++];
 992
 993         return NULL;
 994 }
 995
 996 /**
 997  * label_merge_cmp - cmp of @a merging with @b against @z for set ordering
 998  * @a: label to merge then compare (NOT NULL)
 999  * @b: label to merge then compare (NOT NULL)
1000  * @z: label to compare merge against (NOT NULL)
1001  *
1002  * Assumes: using the most recent versions of @a, @b, and @z
1003  *
1004  * Returns: <0  if a < b
1005  *          ==0 if a == b
1006  *          >0  if a > b
1007  */
1008 static int label_merge_cmp(struct aa_label *a, struct aa_label *b,
1009                            struct aa_label *z)
1010 {
1011         struct aa_profile *p = NULL;
1012         struct label_it i = { };
1013         int k;
1014
1015         AA_BUG(!a);
1016         AA_BUG(!b);
1017         AA_BUG(!z);
1018
1019         for (k = 0;
1020              k < z->size && (p = aa_label_next_in_merge(&i, a, b));
1021              k++) {
1022                 int res = profile_cmp(p, z->vec[k]);
1023
1024                 if (res != 0)
1025                         return res;
1026         }
1027
1028         if (p)
1029                 return 1;
1030         else if (k < z->size)
1031                 return -1;
1032         return 0;
1033 }
1034
1035 /**
1036  * label_merge_insert - create a new label by merging @a and @b
1037  * @new: preallocated label to merge into (NOT NULL)
1038  * @a: label to merge with @b  (NOT NULL)
1039  * @b: label to merge with @a  (NOT NULL)
1040  *
1041  * Requires: preallocated proxy
1042  *
1043  * Returns: ref counted label either @new if merge is unique
1044  *          @a if @b is a subset of @a
1045  *          @b if @a is a subset of @b
1046  *
1047  * NOTE: will not use @new if the merge results in @new == @a or @b
1048  *
1049  *       Must be used within labelset write lock to avoid racing with
1050  *       setting labels stale.
1051  */
1052 static struct aa_label *label_merge_insert(struct aa_label *new,
1053                                            struct aa_label *a,
1054                                            struct aa_label *b)
1055 {
1056         struct aa_label *label;
1057         struct aa_labelset *ls;
1058         struct aa_profile *next;
1059         struct label_it i;
1060         unsigned long flags;
1061         int k = 0, invcount = 0;
1062         bool stale = false;
1063
1064         AA_BUG(!a);
1065         AA_BUG(a->size < 0);
1066         AA_BUG(!b);
1067         AA_BUG(b->size < 0);
1068         AA_BUG(!new);
1069         AA_BUG(new->size < a->size + b->size);
1070
1071         label_for_each_in_merge(i, a, b, next) {
1072                 AA_BUG(!next);
1073                 if (profile_is_stale(next)) {
1074                         new->vec[k] = aa_get_newest_profile(next);
1075                         AA_BUG(!new->vec[k]->label.proxy);
1076                         AA_BUG(!new->vec[k]->label.proxy->label);
1077                         if (next->label.proxy != new->vec[k]->label.proxy)
1078                                 invcount++;
1079                         k++;
1080                         stale = true;
1081                 } else
1082                         new->vec[k++] = aa_get_profile(next);
1083         }
1084         /* set to actual size which is <= allocated len */
1085         new->size = k;
1086         new->vec[k] = NULL;
1087
1088         if (invcount) {
1089                 new->size -= aa_vec_unique(&new->vec[0], new->size,
1090                                            VEC_FLAG_TERMINATE);
1091                 /* TODO: deal with reference labels */
1092                 if (new->size == 1) {
1093                         label = aa_get_label(&new->vec[0]->label);
1094                         return label;
1095                 }
1096         } else if (!stale) {
1097                 /*
1098                  * merge could be same as a || b, note: it is not possible
1099                  * for new->size == a->size == b->size unless a == b
1100                  */
1101                 if (k == a->size)
1102                         return aa_get_label(a);
1103                 else if (k == b->size)
1104                         return aa_get_label(b);
1105         }
1106         if (vec_unconfined(new->vec, new->size))
1107                 new->flags |= FLAG_UNCONFINED;
1108         ls = labels_set(new);
1109         write_lock_irqsave(&ls->lock, flags);
1110         label = __label_insert(labels_set(new), new, false);
1111         write_unlock_irqrestore(&ls->lock, flags);
1112
1113         return label;
1114 }
1115
1116 /**
1117  * labelset_of_merge - find which labelset a merged label should be inserted
1118  * @a: label to merge and insert
1119  * @b: label to merge and insert
1120  *
1121  * Returns: labelset that the merged label should be inserted into
1122  */
1123 static struct aa_labelset *labelset_of_merge(struct aa_label *a,
1124                                              struct aa_label *b)
1125 {
1126         struct aa_ns *nsa = labels_ns(a);
1127         struct aa_ns *nsb = labels_ns(b);
1128
1129         if (ns_cmp(nsa, nsb) <= 0)
1130                 return &nsa->labels;
1131         return &nsb->labels;
1132 }
1133
1134 /**
1135  * __label_find_merge - find label that is equiv to merge of @a and @b
1136  * @ls: set of labels to search (NOT NULL)
1137  * @a: label to merge with @b  (NOT NULL)
1138  * @b: label to merge with @a  (NOT NULL)
1139  *
1140  * Requires: ls->lock read_lock held
1141  *
1142  * Returns: ref counted label that is equiv to merge of @a and @b
1143  *     else NULL if merge of @a and @b is not in set
1144  */
1145 static struct aa_label *__label_find_merge(struct aa_labelset *ls,
1146                                            struct aa_label *a,
1147                                            struct aa_label *b)
1148 {
1149         struct rb_node *node;
1150
1151         AA_BUG(!ls);
1152         AA_BUG(!a);
1153         AA_BUG(!b);
1154
1155         if (a == b)
1156                 return __label_find(a);
1157
1158         node  = ls->root.rb_node;
1159         while (node) {
1160                 struct aa_label *this = container_of(node, struct aa_label,
1161                                                      node);
1162                 int result = label_merge_cmp(a, b, this);
1163
1164                 if (result < 0)
1165                         node = node->rb_left;
1166                 else if (result > 0)
1167                         node = node->rb_right;
1168                 else
1169                         return __aa_get_label(this);
1170         }
1171
1172         return NULL;
1173 }
1174
1175
1176 /**
1177  * aa_label_find_merge - find label that is equiv to merge of @a and @b
1178  * @a: label to merge with @b  (NOT NULL)
1179  * @b: label to merge with @a  (NOT NULL)
1180  *
1181  * Requires: labels be fully constructed with a valid ns
1182  *
1183  * Returns: ref counted label that is equiv to merge of @a and @b
1184  *     else NULL if merge of @a and @b is not in set
1185  */
1186 struct aa_label *aa_label_find_merge(struct aa_label *a, struct aa_label *b)
1187 {
1188         struct aa_labelset *ls;
1189         struct aa_label *label, *ar = NULL, *br = NULL;
1190         unsigned long flags;
1191
1192         AA_BUG(!a);
1193         AA_BUG(!b);
1194
1195         if (label_is_stale(a))
1196                 a = ar = aa_get_newest_label(a);
1197         if (label_is_stale(b))
1198                 b = br = aa_get_newest_label(b);
1199         ls = labelset_of_merge(a, b);
1200         read_lock_irqsave(&ls->lock, flags);
1201         label = __label_find_merge(ls, a, b);
1202         read_unlock_irqrestore(&ls->lock, flags);
1203         aa_put_label(ar);
1204         aa_put_label(br);
1205
1206         return label;
1207 }
1208
1209 /**
1210  * aa_label_merge - attempt to insert new merged label of @a and @b
1211  * @ls: set of labels to insert label into (NOT NULL)
1212  * @a: label to merge with @b  (NOT NULL)
1213  * @b: label to merge with @a  (NOT NULL)
1214  * @gfp: memory allocation type
1215  *
1216  * Requires: caller to hold valid refs on @a and @b
1217  *           labels be fully constructed with a valid ns
1218  *
1219  * Returns: ref counted new label if successful in inserting merge of a & b
1220  *     else ref counted equivalent label that is already in the set.
1221  *     else NULL if could not create label (-ENOMEM)
1222  */
1223 struct aa_label *aa_label_merge(struct aa_label *a, struct aa_label *b,
1224                                 gfp_t gfp)
1225 {
1226         struct aa_label *label = NULL;
1227
1228         AA_BUG(!a);
1229         AA_BUG(!b);
1230
1231         if (a == b)
1232                 return aa_get_newest_label(a);
1233
1234         /* TODO: enable when read side is lockless
1235          * check if label exists before taking locks
1236         if (!label_is_stale(a) && !label_is_stale(b))
1237                 label = aa_label_find_merge(a, b);
1238         */
1239
1240         if (!label) {
1241                 struct aa_label *new;
1242
1243                 a = aa_get_newest_label(a);
1244                 b = aa_get_newest_label(b);
1245
1246                 /* could use label_merge_len(a, b), but requires double
1247                  * comparison for small savings
1248                  */
1249                 new = aa_label_alloc(a->size + b->size, NULL, gfp);
1250                 if (!new)
1251                         goto out;
1252
1253                 label = label_merge_insert(new, a, b);
1254                 label_free_or_put_new(label, new);
1255 out:
1256                 aa_put_label(a);
1257                 aa_put_label(b);
1258         }
1259
1260         return label;
1261 }
1262
1263 static inline bool label_is_visible(struct aa_profile *profile,
1264                                     struct aa_label *label)
1265 {
1266         return aa_ns_visible(profile->ns, labels_ns(label), true);
1267 }
1268
1269 /* match a profile and its associated ns component if needed
1270  * Assumes visibility test has already been done.
1271  * If a subns profile is not to be matched should be prescreened with
1272  * visibility test.
1273  */
1274 static inline unsigned int match_component(struct aa_profile *profile,
1275                                            struct aa_profile *tp,
1276                                            unsigned int state)
1277 {
1278         const char *ns_name;
1279
1280         if (profile->ns == tp->ns)
1281                 return aa_dfa_match(profile->policy.dfa, state, tp->base.hname);
1282
1283         /* try matching with namespace name and then profile */
1284         ns_name = aa_ns_name(profile->ns, tp->ns, true);
1285         state = aa_dfa_match_len(profile->policy.dfa, state, ":", 1);
1286         state = aa_dfa_match(profile->policy.dfa, state, ns_name);
1287         state = aa_dfa_match_len(profile->policy.dfa, state, ":", 1);
1288         return aa_dfa_match(profile->policy.dfa, state, tp->base.hname);
1289 }
1290
1291 /**
1292  * label_compound_match - find perms for full compound label
1293  * @profile: profile to find perms for
1294  * @label: label to check access permissions for
1295  * @start: state to start match in
1296  * @subns: whether to do permission checks on components in a subns
1297  * @request: permissions to request
1298  * @perms: perms struct to set
1299  *
1300  * Returns: 0 on success else ERROR
1301  *
1302  * For the label A//&B//&C this does the perm match for A//&B//&C
1303  * @perms should be preinitialized with allperms OR a previous permission
1304  *        check to be stacked.
1305  */
1306 static int label_compound_match(struct aa_profile *profile,
1307                                 struct aa_label *label,
1308                                 unsigned int state, bool subns, u32 request,
1309                                 struct aa_perms *perms)
1310 {
1311         struct aa_profile *tp;
1312         struct label_it i;
1313
1314         /* find first subcomponent that is visible */
1315         label_for_each(i, label, tp) {
1316                 if (!aa_ns_visible(profile->ns, tp->ns, subns))
1317                         continue;
1318                 state = match_component(profile, tp, state);
1319                 if (!state)
1320                         goto fail;
1321                 goto next;
1322         }
1323
1324         /* no component visible */
1325         *perms = allperms;
1326         return 0;
1327
1328 next:
1329         label_for_each_cont(i, label, tp) {
1330                 if (!aa_ns_visible(profile->ns, tp->ns, subns))
1331                         continue;
1332                 state = aa_dfa_match(profile->policy.dfa, state, "//&");
1333                 state = match_component(profile, tp, state);
1334                 if (!state)
1335                         goto fail;
1336         }
1337         aa_compute_perms(profile->policy.dfa, state, perms);
1338         aa_apply_modes_to_perms(profile, perms);
1339         if ((perms->allow & request) != request)
1340                 return -EACCES;
1341
1342         return 0;
1343
1344 fail:
1345         *perms = nullperms;
1346         return state;
1347 }
1348
1349 /**
1350  * label_components_match - find perms for all subcomponents of a label
1351  * @profile: profile to find perms for
1352  * @label: label to check access permissions for
1353  * @start: state to start match in
1354  * @subns: whether to do permission checks on components in a subns
1355  * @request: permissions to request
1356  * @perms: an initialized perms struct to add accumulation to
1357  *
1358  * Returns: 0 on success else ERROR
1359  *
1360  * For the label A//&B//&C this does the perm match for each of A and B and C
1361  * @perms should be preinitialized with allperms OR a previous permission
1362  *        check to be stacked.
1363  */
1364 static int label_components_match(struct aa_profile *profile,
1365                                   struct aa_label *label, unsigned int start,
1366                                   bool subns, u32 request,
1367                                   struct aa_perms *perms)
1368 {
1369         struct aa_profile *tp;
1370         struct label_it i;
1371         struct aa_perms tmp;
1372         unsigned int state = 0;
1373
1374         /* find first subcomponent to test */
1375         label_for_each(i, label, tp) {
1376                 if (!aa_ns_visible(profile->ns, tp->ns, subns))
1377                         continue;
1378                 state = match_component(profile, tp, start);
1379                 if (!state)
1380                         goto fail;
1381                 goto next;
1382         }
1383
1384         /* no subcomponents visible - no change in perms */
1385         return 0;
1386
1387 next:
1388         aa_compute_perms(profile->policy.dfa, state, &tmp);
1389         aa_apply_modes_to_perms(profile, &tmp);
1390         aa_perms_accum(perms, &tmp);
1391         label_for_each_cont(i, label, tp) {
1392                 if (!aa_ns_visible(profile->ns, tp->ns, subns))
1393                         continue;
1394                 state = match_component(profile, tp, start);
1395                 if (!state)
1396                         goto fail;
1397                 aa_compute_perms(profile->policy.dfa, state, &tmp);
1398                 aa_apply_modes_to_perms(profile, &tmp);
1399                 aa_perms_accum(perms, &tmp);
1400         }
1401
1402         if ((perms->allow & request) != request)
1403                 return -EACCES;
1404
1405         return 0;
1406
1407 fail:
1408         *perms = nullperms;
1409         return -EACCES;
1410 }
1411
1412 /**
1413  * aa_label_match - do a multi-component label match
1414  * @profile: profile to match against (NOT NULL)
1415  * @label: label to match (NOT NULL)
1416  * @state: state to start in
1417  * @subns: whether to match subns components
1418  * @request: permission request
1419  * @perms: Returns computed perms (NOT NULL)
1420  *
1421  * Returns: the state the match finished in, may be the none matching state
1422  */
1423 int aa_label_match(struct aa_profile *profile, struct aa_label *label,
1424                    unsigned int state, bool subns, u32 request,
1425                    struct aa_perms *perms)
1426 {
1427         int error = label_compound_match(profile, label, state, subns, request,
1428                                          perms);
1429         if (!error)
1430                 return error;
1431
1432         *perms = allperms;
1433         return label_components_match(profile, label, state, subns, request,
1434                                       perms);
1435 }
1436
1437
1438 /**
1439  * aa_update_label_name - update a label to have a stored name
1440  * @ns: ns being viewed from (NOT NULL)
1441  * @label: label to update (NOT NULL)
1442  * @gfp: type of memory allocation
1443  *
1444  * Requires: labels_set(label) not locked in caller
1445  *
1446  * note: only updates the label name if it does not have a name already
1447  *       and if it is in the labelset
1448  */
1449 bool aa_update_label_name(struct aa_ns *ns, struct aa_label *label, gfp_t gfp)
1450 {
1451         struct aa_labelset *ls;
1452         unsigned long flags;
1453         char __counted *name;
1454         bool res = false;
1455
1456         AA_BUG(!ns);
1457         AA_BUG(!label);
1458
1459         if (label->hname || labels_ns(label) != ns)
1460                 return res;
1461
1462         if (aa_label_acntsxprint(&name, ns, label, FLAGS_NONE, gfp) < 0)
1463                 return res;
1464
1465         ls = labels_set(label);
1466         write_lock_irqsave(&ls->lock, flags);
1467         if (!label->hname && label->flags & FLAG_IN_TREE) {
1468                 label->hname = name;
1469                 res = true;
1470         } else
1471                 aa_put_str(name);
1472         write_unlock_irqrestore(&ls->lock, flags);
1473
1474         return res;
1475 }
1476
1477 /*
1478  * cached label name is present and visible
1479  * @label->hname only exists if label is namespace hierachical
1480  */
1481 static inline bool use_label_hname(struct aa_ns *ns, struct aa_label *label,
1482                                    int flags)
1483 {
1484         if (label->hname && (!ns || labels_ns(label) == ns) &&
1485             !(flags & ~FLAG_SHOW_MODE))
1486                 return true;
1487
1488         return false;
1489 }
1490
1491 /* helper macro for snprint routines */
1492 #define update_for_len(total, len, size, str)   \
1493 do {                                    \
1494         size_t ulen = len;              \
1495                                         \
1496         AA_BUG(len < 0);                \
1497         total += ulen;                  \
1498         ulen = min(ulen, size);         \
1499         size -= ulen;                   \
1500         str += ulen;                    \
1501 } while (0)
1502
1503 /**
1504  * aa_profile_snxprint - print a profile name to a buffer
1505  * @str: buffer to write to. (MAY BE NULL if @size == 0)
1506  * @size: size of buffer
1507  * @view: namespace profile is being viewed from
1508  * @profile: profile to view (NOT NULL)
1509  * @flags: whether to include the mode string
1510  * @prev_ns: last ns printed when used in compound print
1511  *
1512  * Returns: size of name written or would be written if larger than
1513  *          available buffer
1514  *
1515  * Note: will not print anything if the profile is not visible
1516  */
1517 static int aa_profile_snxprint(char *str, size_t size, struct aa_ns *view,
1518                                struct aa_profile *profile, int flags,
1519                                struct aa_ns **prev_ns)
1520 {
1521         const char *ns_name = NULL;
1522
1523         AA_BUG(!str && size != 0);
1524         AA_BUG(!profile);
1525
1526         if (!view)
1527                 view = profiles_ns(profile);
1528
1529         if (view != profile->ns &&
1530             (!prev_ns || (*prev_ns != profile->ns))) {
1531                 if (prev_ns)
1532                         *prev_ns = profile->ns;
1533                 ns_name = aa_ns_name(view, profile->ns,
1534                                      flags & FLAG_VIEW_SUBNS);
1535                 if (ns_name == aa_hidden_ns_name) {
1536                         if (flags & FLAG_HIDDEN_UNCONFINED)
1537                                 return snprintf(str, size, "%s", "unconfined");
1538                         return snprintf(str, size, "%s", ns_name);
1539                 }
1540         }
1541
1542         if ((flags & FLAG_SHOW_MODE) && profile != profile->ns->unconfined) {
1543                 const char *modestr = aa_profile_mode_names[profile->mode];
1544
1545                 if (ns_name)
1546                         return snprintf(str, size, ":%s:%s (%s)", ns_name,
1547                                         profile->base.hname, modestr);
1548                 return snprintf(str, size, "%s (%s)", profile->base.hname,
1549                                 modestr);
1550         }
1551
1552         if (ns_name)
1553                 return snprintf(str, size, ":%s:%s", ns_name,
1554                                 profile->base.hname);
1555         return snprintf(str, size, "%s", profile->base.hname);
1556 }
1557
1558 static const char *label_modename(struct aa_ns *ns, struct aa_label *label,
1559                                   int flags)
1560 {
1561         struct aa_profile *profile;
1562         struct label_it i;
1563         int mode = -1, count = 0;
1564
1565         label_for_each(i, label, profile) {
1566                 if (aa_ns_visible(ns, profile->ns, flags & FLAG_VIEW_SUBNS)) {
1567                         count++;
1568                         if (profile == profile->ns->unconfined)
1569                                 /* special case unconfined so stacks with
1570                                  * unconfined don't report as mixed. ie.
1571                                  * profile_foo//&:ns1:unconfined (mixed)
1572                                  */
1573                                 continue;
1574                         if (mode == -1)
1575                                 mode = profile->mode;
1576                         else if (mode != profile->mode)
1577                                 return "mixed";
1578                 }
1579         }
1580
1581         if (count == 0)
1582                 return "-";
1583         if (mode == -1)
1584                 /* everything was unconfined */
1585                 mode = APPARMOR_UNCONFINED;
1586
1587         return aa_profile_mode_names[mode];
1588 }
1589
1590 /* if any visible label is not unconfined the display_mode returns true */
1591 static inline bool display_mode(struct aa_ns *ns, struct aa_label *label,
1592                                 int flags)
1593 {
1594         if ((flags & FLAG_SHOW_MODE)) {
1595                 struct aa_profile *profile;
1596                 struct label_it i;
1597
1598                 label_for_each(i, label, profile) {
1599                         if (aa_ns_visible(ns, profile->ns,
1600                                           flags & FLAG_VIEW_SUBNS) &&
1601                             profile != profile->ns->unconfined)
1602                                 return true;
1603                 }
1604                 /* only ns->unconfined in set of profiles in ns */
1605                 return false;
1606         }
1607
1608         return false;
1609 }
1610
1611 /**
1612  * aa_label_snxprint - print a label name to a string buffer
1613  * @str: buffer to write to. (MAY BE NULL if @size == 0)
1614  * @size: size of buffer
1615  * @ns: namespace profile is being viewed from
1616  * @label: label to view (NOT NULL)
1617  * @flags: whether to include the mode string
1618  *
1619  * Returns: size of name written or would be written if larger than
1620  *          available buffer
1621  *
1622  * Note: labels do not have to be strictly hierarchical to the ns as
1623  *       objects may be shared across different namespaces and thus
1624  *       pickup labeling from each ns.  If a particular part of the
1625  *       label is not visible it will just be excluded.  And if none
1626  *       of the label is visible "---" will be used.
1627  */
1628 int aa_label_snxprint(char *str, size_t size, struct aa_ns *ns,
1629                       struct aa_label *label, int flags)
1630 {
1631         struct aa_profile *profile;
1632         struct aa_ns *prev_ns = NULL;
1633         struct label_it i;
1634         int count = 0, total = 0;
1635         ssize_t len;
1636
1637         AA_BUG(!str && size != 0);
1638         AA_BUG(!label);
1639
1640         if (AA_DEBUG_LABEL && (flags & FLAG_ABS_ROOT)) {
1641                 ns = root_ns;
1642                 len = snprintf(str, size, "_");
1643                 update_for_len(total, len, size, str);
1644         } else if (!ns) {
1645                 ns = labels_ns(label);
1646         }
1647
1648         label_for_each(i, label, profile) {
1649                 if (aa_ns_visible(ns, profile->ns, flags & FLAG_VIEW_SUBNS)) {
1650                         if (count > 0) {
1651                                 len = snprintf(str, size, "//&");
1652                                 update_for_len(total, len, size, str);
1653                         }
1654                         len = aa_profile_snxprint(str, size, ns, profile,
1655                                                   flags & FLAG_VIEW_SUBNS,
1656                                                   &prev_ns);
1657                         update_for_len(total, len, size, str);
1658                         count++;
1659                 }
1660         }
1661
1662         if (count == 0) {
1663                 if (flags & FLAG_HIDDEN_UNCONFINED)
1664                         return snprintf(str, size, "%s", "unconfined");
1665                 return snprintf(str, size, "%s", aa_hidden_ns_name);
1666         }
1667
1668         /* count == 1 && ... is for backwards compat where the mode
1669          * is not displayed for 'unconfined' in the current ns
1670          */
1671         if (display_mode(ns, label, flags)) {
1672                 len = snprintf(str, size, " (%s)",
1673                                label_modename(ns, label, flags));
1674                 update_for_len(total, len, size, str);
1675         }
1676
1677         return total;
1678 }
1679 #undef update_for_len
1680
1681 /**
1682  * aa_label_asxprint - allocate a string buffer and print label into it
1683  * @strp: Returns - the allocated buffer with the label name. (NOT NULL)
1684  * @ns: namespace profile is being viewed from
1685  * @label: label to view (NOT NULL)
1686  * @flags: flags controlling what label info is printed
1687  * @gfp: kernel memory allocation type
1688  *
1689  * Returns: size of name written or would be written if larger than
1690  *          available buffer
1691  */
1692 int aa_label_asxprint(char **strp, struct aa_ns *ns, struct aa_label *label,
1693                       int flags, gfp_t gfp)
1694 {
1695         int size;
1696
1697         AA_BUG(!strp);
1698         AA_BUG(!label);
1699
1700         size = aa_label_snxprint(NULL, 0, ns, label, flags);
1701         if (size < 0)
1702                 return size;
1703
1704         *strp = kmalloc(size + 1, gfp);
1705         if (!*strp)
1706                 return -ENOMEM;
1707         return aa_label_snxprint(*strp, size + 1, ns, label, flags);
1708 }
1709
1710 /**
1711  * aa_label_acntsxprint - allocate a __counted string buffer and print label
1712  * @strp: buffer to write to.
1713  * @ns: namespace profile is being viewed from
1714  * @label: label to view (NOT NULL)
1715  * @flags: flags controlling what label info is printed
1716  * @gfp: kernel memory allocation type
1717  *
1718  * Returns: size of name written or would be written if larger than
1719  *          available buffer
1720  */
1721 int aa_label_acntsxprint(char __counted **strp, struct aa_ns *ns,
1722                          struct aa_label *label, int flags, gfp_t gfp)
1723 {
1724         int size;
1725
1726         AA_BUG(!strp);
1727         AA_BUG(!label);
1728
1729         size = aa_label_snxprint(NULL, 0, ns, label, flags);
1730         if (size < 0)
1731                 return size;
1732
1733         *strp = aa_str_alloc(size + 1, gfp);
1734         if (!*strp)
1735                 return -ENOMEM;
1736         return aa_label_snxprint(*strp, size + 1, ns, label, flags);
1737 }
1738
1739
1740 void aa_label_xaudit(struct audit_buffer *ab, struct aa_ns *ns,
1741                      struct aa_label *label, int flags, gfp_t gfp)
1742 {
1743         const char *str;
1744         char *name = NULL;
1745         int len;
1746
1747         AA_BUG(!ab);
1748         AA_BUG(!label);
1749
1750         if (!use_label_hname(ns, label, flags) ||
1751             display_mode(ns, label, flags)) {
1752                 len  = aa_label_asxprint(&name, ns, label, flags, gfp);
1753                 if (len < 0) {
1754                         AA_DEBUG("label print error");
1755                         return;
1756                 }
1757                 str = name;
1758         } else {
1759                 str = (char *) label->hname;
1760                 len = strlen(str);
1761         }
1762         if (audit_string_contains_control(str, len))
1763                 audit_log_n_hex(ab, str, len);
1764         else
1765                 audit_log_n_string(ab, str, len);
1766
1767         kfree(name);
1768 }
1769
1770 void aa_label_seq_xprint(struct seq_file *f, struct aa_ns *ns,
1771                          struct aa_label *label, int flags, gfp_t gfp)
1772 {
1773         AA_BUG(!f);
1774         AA_BUG(!label);
1775
1776         if (!use_label_hname(ns, label, flags)) {
1777                 char *str;
1778                 int len;
1779
1780                 len = aa_label_asxprint(&str, ns, label, flags, gfp);
1781                 if (len < 0) {
1782                         AA_DEBUG("label print error");
1783                         return;
1784                 }
1785                 seq_printf(f, "%s", str);
1786                 kfree(str);
1787         } else if (display_mode(ns, label, flags))
1788                 seq_printf(f, "%s (%s)", label->hname,
1789                            label_modename(ns, label, flags));
1790         else
1791                 seq_printf(f, "%s", label->hname);
1792 }
1793
1794 void aa_label_xprintk(struct aa_ns *ns, struct aa_label *label, int flags,
1795                       gfp_t gfp)
1796 {
1797         AA_BUG(!label);
1798
1799         if (!use_label_hname(ns, label, flags)) {
1800                 char *str;
1801                 int len;
1802
1803                 len = aa_label_asxprint(&str, ns, label, flags, gfp);
1804                 if (len < 0) {
1805                         AA_DEBUG("label print error");
1806                         return;
1807                 }
1808                 pr_info("%s", str);
1809                 kfree(str);
1810         } else if (display_mode(ns, label, flags))
1811                 pr_info("%s (%s)", label->hname,
1812                        label_modename(ns, label, flags));
1813         else
1814                 pr_info("%s", label->hname);
1815 }
1816
1817 void aa_label_audit(struct audit_buffer *ab, struct aa_label *label, gfp_t gfp)
1818 {
1819         struct aa_ns *ns = aa_get_current_ns();
1820
1821         aa_label_xaudit(ab, ns, label, FLAG_VIEW_SUBNS, gfp);
1822         aa_put_ns(ns);
1823 }
1824
1825 void aa_label_seq_print(struct seq_file *f, struct aa_label *label, gfp_t gfp)
1826 {
1827         struct aa_ns *ns = aa_get_current_ns();
1828
1829         aa_label_seq_xprint(f, ns, label, FLAG_VIEW_SUBNS, gfp);
1830         aa_put_ns(ns);
1831 }
1832
1833 void aa_label_printk(struct aa_label *label, gfp_t gfp)
1834 {
1835         struct aa_ns *ns = aa_get_current_ns();
1836
1837         aa_label_xprintk(ns, label, FLAG_VIEW_SUBNS, gfp);
1838         aa_put_ns(ns);
1839 }
1840
1841 static int label_count_strn_entries(const char *str, size_t n)
1842 {
1843         const char *end = str + n;
1844         const char *split;
1845         int count = 1;
1846
1847         AA_BUG(!str);
1848
1849         for (split = aa_label_strn_split(str, end - str);
1850              split;
1851              split = aa_label_strn_split(str, end - str)) {
1852                 count++;
1853                 str = split + 3;
1854         }
1855
1856         return count;
1857 }
1858
1859 /*
1860  * ensure stacks with components like
1861  *   :ns:A//&B
1862  * have :ns: applied to both 'A' and 'B' by making the lookup relative
1863  * to the base if the lookup specifies an ns, else making the stacked lookup
1864  * relative to the last embedded ns in the string.
1865  */
1866 static struct aa_profile *fqlookupn_profile(struct aa_label *base,
1867                                             struct aa_label *currentbase,
1868                                             const char *str, size_t n)
1869 {
1870         const char *first = skipn_spaces(str, n);
1871
1872         if (first && *first == ':')
1873                 return aa_fqlookupn_profile(base, str, n);
1874
1875         return aa_fqlookupn_profile(currentbase, str, n);
1876 }
1877
1878 /**
1879  * aa_label_strn_parse - parse, validate and convert a text string to a label
1880  * @base: base label to use for lookups (NOT NULL)
1881  * @str: null terminated text string (NOT NULL)
1882  * @n: length of str to parse, will stop at \0 if encountered before n
1883  * @gfp: allocation type
1884  * @create: true if should create compound labels if they don't exist
1885  * @force_stack: true if should stack even if no leading &
1886  *
1887  * Returns: the matching refcounted label if present
1888  *     else ERRPTR
1889  */
1890 struct aa_label *aa_label_strn_parse(struct aa_label *base, const char *str,
1891                                      size_t n, gfp_t gfp, bool create,
1892                                      bool force_stack)
1893 {
1894         DEFINE_VEC(profile, vec);
1895         struct aa_label *label, *currbase = base;
1896         int i, len, stack = 0, error;
1897         const char *end = str + n;
1898         const char *split;
1899
1900         AA_BUG(!base);
1901         AA_BUG(!str);
1902
1903         str = skipn_spaces(str, n);
1904         if (str == NULL || (AA_DEBUG_LABEL && *str == '_' &&
1905                             base != &root_ns->unconfined->label))
1906                 return ERR_PTR(-EINVAL);
1907
1908         len = label_count_strn_entries(str, end - str);
1909         if (*str == '&' || force_stack) {
1910                 /* stack on top of base */
1911                 stack = base->size;
1912                 len += stack;
1913                 if (*str == '&')
1914                         str++;
1915         }
1916
1917         error = vec_setup(profile, vec, len, gfp);
1918         if (error)
1919                 return ERR_PTR(error);
1920
1921         for (i = 0; i < stack; i++)
1922                 vec[i] = aa_get_profile(base->vec[i]);
1923
1924         for (split = aa_label_strn_split(str, end - str), i = stack;
1925              split && i < len; i++) {
1926                 vec[i] = fqlookupn_profile(base, currbase, str, split - str);
1927                 if (!vec[i])
1928                         goto fail;
1929                 /*
1930                  * if component specified a new ns it becomes the new base
1931                  * so that subsequent lookups are relative to it
1932                  */
1933                 if (vec[i]->ns != labels_ns(currbase))
1934                         currbase = &vec[i]->label;
1935                 str = split + 3;
1936                 split = aa_label_strn_split(str, end - str);
1937         }
1938         /* last element doesn't have a split */
1939         if (i < len) {
1940                 vec[i] = fqlookupn_profile(base, currbase, str, end - str);
1941                 if (!vec[i])
1942                         goto fail;
1943         }
1944         if (len == 1)
1945                 /* no need to free vec as len < LOCAL_VEC_ENTRIES */
1946                 return &vec[0]->label;
1947
1948         len -= aa_vec_unique(vec, len, VEC_FLAG_TERMINATE);
1949         /* TODO: deal with reference labels */
1950         if (len == 1) {
1951                 label = aa_get_label(&vec[0]->label);
1952                 goto out;
1953         }
1954
1955         if (create)
1956                 label = aa_vec_find_or_create_label(vec, len, gfp);
1957         else
1958                 label = vec_find(vec, len);
1959         if (!label)
1960                 goto fail;
1961
1962 out:
1963         /* use adjusted len from after vec_unique, not original */
1964         vec_cleanup(profile, vec, len);
1965         return label;
1966
1967 fail:
1968         label = ERR_PTR(-ENOENT);
1969         goto out;
1970 }
1971
1972 struct aa_label *aa_label_parse(struct aa_label *base, const char *str,
1973                                 gfp_t gfp, bool create, bool force_stack)
1974 {
1975         return aa_label_strn_parse(base, str, strlen(str), gfp, create,
1976                                    force_stack);
1977 }
1978
1979 /**
1980  * aa_labelset_destroy - remove all labels from the label set
1981  * @ls: label set to cleanup (NOT NULL)
1982  *
1983  * Labels that are removed from the set may still exist beyond the set
1984  * being destroyed depending on their reference counting
1985  */
1986 void aa_labelset_destroy(struct aa_labelset *ls)
1987 {
1988         struct rb_node *node;
1989         unsigned long flags;
1990
1991         AA_BUG(!ls);
1992
1993         write_lock_irqsave(&ls->lock, flags);
1994         for (node = rb_first(&ls->root); node; node = rb_first(&ls->root)) {
1995                 struct aa_label *this = rb_entry(node, struct aa_label, node);
1996
1997                 if (labels_ns(this) != root_ns)
1998                         __label_remove(this,
1999                                        ns_unconfined(labels_ns(this)->parent));
2000                 else
2001                         __label_remove(this, NULL);
2002         }
2003         write_unlock_irqrestore(&ls->lock, flags);
2004 }
2005
2006 /*
2007  * @ls: labelset to init (NOT NULL)
2008  */
2009 void aa_labelset_init(struct aa_labelset *ls)
2010 {
2011         AA_BUG(!ls);
2012
2013         rwlock_init(&ls->lock);
2014         ls->root = RB_ROOT;
2015 }
2016
2017 static struct aa_label *labelset_next_stale(struct aa_labelset *ls)
2018 {
2019         struct aa_label *label;
2020         struct rb_node *node;
2021         unsigned long flags;
2022
2023         AA_BUG(!ls);
2024
2025         read_lock_irqsave(&ls->lock, flags);
2026
2027         __labelset_for_each(ls, node) {
2028                 label = rb_entry(node, struct aa_label, node);
2029                 if ((label_is_stale(label) ||
2030                      vec_is_stale(label->vec, label->size)) &&
2031                     __aa_get_label(label))
2032                         goto out;
2033
2034         }
2035         label = NULL;
2036
2037 out:
2038         read_unlock_irqrestore(&ls->lock, flags);
2039
2040         return label;
2041 }
2042
2043 /**
2044  * __label_update - insert updated version of @label into labelset
2045  * @label - the label to update/replace
2046  *
2047  * Returns: new label that is up to date
2048  *     else NULL on failure
2049  *
2050  * Requires: @ns lock be held
2051  *
2052  * Note: worst case is the stale @label does not get updated and has
2053  *       to be updated at a later time.
2054  */
2055 static struct aa_label *__label_update(struct aa_label *label)
2056 {
2057         struct aa_label *new, *tmp;
2058         struct aa_labelset *ls;
2059         unsigned long flags;
2060         int i, invcount = 0;
2061
2062         AA_BUG(!label);
2063         AA_BUG(!mutex_is_locked(&labels_ns(label)->lock));
2064
2065         new = aa_label_alloc(label->size, label->proxy, GFP_KERNEL);
2066         if (!new)
2067                 return NULL;
2068
2069         /*
2070          * while holding the ns_lock will stop profile replacement, removal,
2071          * and label updates, label merging and removal can be occurring
2072          */
2073         ls = labels_set(label);
2074         write_lock_irqsave(&ls->lock, flags);
2075         for (i = 0; i < label->size; i++) {
2076                 AA_BUG(!label->vec[i]);
2077                 new->vec[i] = aa_get_newest_profile(label->vec[i]);
2078                 AA_BUG(!new->vec[i]);
2079                 AA_BUG(!new->vec[i]->label.proxy);
2080                 AA_BUG(!new->vec[i]->label.proxy->label);
2081                 if (new->vec[i]->label.proxy != label->vec[i]->label.proxy)
2082                         invcount++;
2083         }
2084
2085         /* updated stale label by being removed/renamed from labelset */
2086         if (invcount) {
2087                 new->size -= aa_vec_unique(&new->vec[0], new->size,
2088                                            VEC_FLAG_TERMINATE);
2089                 /* TODO: deal with reference labels */
2090                 if (new->size == 1) {
2091                         tmp = aa_get_label(&new->vec[0]->label);
2092                         AA_BUG(tmp == label);
2093                         goto remove;
2094                 }
2095                 if (labels_set(label) != labels_set(new)) {
2096                         write_unlock_irqrestore(&ls->lock, flags);
2097                         tmp = aa_label_insert(labels_set(new), new);
2098                         write_lock_irqsave(&ls->lock, flags);
2099                         goto remove;
2100                 }
2101         } else
2102                 AA_BUG(labels_ns(label) != labels_ns(new));
2103
2104         tmp = __label_insert(labels_set(label), new, true);
2105 remove:
2106         /* ensure label is removed, and redirected correctly */
2107         __label_remove(label, tmp);
2108         write_unlock_irqrestore(&ls->lock, flags);
2109         label_free_or_put_new(tmp, new);
2110
2111         return tmp;
2112 }
2113
2114 /**
2115  * __labelset_update - update labels in @ns
2116  * @ns: namespace to update labels in  (NOT NULL)
2117  *
2118  * Requires: @ns lock be held
2119  *
2120  * Walk the labelset ensuring that all labels are up to date and valid
2121  * Any label that has a stale component is marked stale and replaced and
2122  * by an updated version.
2123  *
2124  * If failures happen due to memory pressures then stale labels will
2125  * be left in place until the next pass.
2126  */
2127 static void __labelset_update(struct aa_ns *ns)
2128 {
2129         struct aa_label *label;
2130
2131         AA_BUG(!ns);
2132         AA_BUG(!mutex_is_locked(&ns->lock));
2133
2134         do {
2135                 label = labelset_next_stale(&ns->labels);
2136                 if (label) {
2137                         struct aa_label *l = __label_update(label);
2138
2139                         aa_put_label(l);
2140                         aa_put_label(label);
2141                 }
2142         } while (label);
2143 }
2144
2145 /**
2146  * __aa_labelset_udate_subtree - update all labels with a stale component
2147  * @ns: ns to start update at (NOT NULL)
2148  *
2149  * Requires: @ns lock be held
2150  *
2151  * Invalidates labels based on @p in @ns and any children namespaces.
2152  */
2153 void __aa_labelset_update_subtree(struct aa_ns *ns)
2154 {
2155         struct aa_ns *child;
2156
2157         AA_BUG(!ns);
2158         AA_BUG(!mutex_is_locked(&ns->lock));
2159
2160         __labelset_update(ns);
2161
2162         list_for_each_entry(child, &ns->sub_ns, base.list) {
2163                 mutex_lock_nested(&child->lock, child->level);
2164                 __aa_labelset_update_subtree(child);
2165                 mutex_unlock(&child->lock);
2166         }
2167 }