Branch data     Line data    Source code

       1                 :            : // SPDX-License-Identifier: GPL-2.0-only
       2                 :            : /*
       3                 :            :  * AppArmor security module
       4                 :            :  *
       5                 :            :  * This file contains AppArmor policy manipulation functions
       6                 :            :  *
       7                 :            :  * Copyright (C) 1998-2008 Novell/SUSE
       8                 :            :  * Copyright 2009-2017 Canonical Ltd.
       9                 :            :  *
      10                 :            :  * AppArmor policy namespaces, allow for different sets of policies
      11                 :            :  * to be loaded for tasks within the namespace.
      12                 :            :  */
      13                 :            : 
      14                 :            : #include <linux/list.h>
      15                 :            : #include <linux/mutex.h>
      16                 :            : #include <linux/slab.h>
      17                 :            : #include <linux/string.h>
      18                 :            : 
      19                 :            : #include "include/apparmor.h"
      20                 :            : #include "include/cred.h"
      21                 :            : #include "include/policy_ns.h"
      22                 :            : #include "include/label.h"
      23                 :            : #include "include/policy.h"
      24                 :            : 
      25                 :            : /* root profile namespace */
      26                 :            : struct aa_ns *root_ns;
      27                 :            : const char *aa_hidden_ns_name = "---";
      28                 :            : 
      29                 :            : /**
      30                 :            :  * aa_ns_visible - test if @view is visible from @curr
      31                 :            :  * @curr: namespace to treat as the parent (NOT NULL)
      32                 :            :  * @view: namespace to test if visible from @curr (NOT NULL)
      33                 :            :  * @subns: whether view of a subns is allowed
      34                 :            :  *
      35                 :            :  * Returns: true if @view is visible from @curr else false
      36                 :            :  */
      37                 :          0 : bool aa_ns_visible(struct aa_ns *curr, struct aa_ns *view, bool subns)
      38                 :            : {
      39                 :          0 :         if (curr == view)
      40                 :            :                 return true;
      41                 :            : 
      42                 :          0 :         if (!subns)
      43                 :            :                 return false;
      44                 :            : 
      45                 :          0 :         for ( ; view; view = view->parent) {
      46                 :          0 :                 if (view->parent == curr)
      47                 :            :                         return true;
      48                 :            :         }
      49                 :            : 
      50                 :            :         return false;
      51                 :            : }
      52                 :            : 
      53                 :            : /**
      54                 :            :  * aa_na_name - Find the ns name to display for @view from @curr
      55                 :            :  * @curr - current namespace (NOT NULL)
      56                 :            :  * @view - namespace attempting to view (NOT NULL)
      57                 :            :  * @subns - are subns visible
      58                 :            :  *
      59                 :            :  * Returns: name of @view visible from @curr
      60                 :            :  */
      61                 :          0 : const char *aa_ns_name(struct aa_ns *curr, struct aa_ns *view, bool subns)
      62                 :            : {
      63                 :            :         /* if view == curr then the namespace name isn't displayed */
      64                 :          0 :         if (curr == view)
      65                 :            :                 return "";
      66                 :            : 
      67                 :          0 :         if (aa_ns_visible(curr, view, subns)) {
      68                 :            :                 /* at this point if a ns is visible it is in a view ns
      69                 :            :                  * thus the curr ns.hname is a prefix of its name.
      70                 :            :                  * Only output the virtualized portion of the name
      71                 :            :                  * Add + 2 to skip over // separating curr hname prefix
      72                 :            :                  * from the visible tail of the views hname
      73                 :            :                  */
      74                 :          0 :                 return view->base.hname + strlen(curr->base.hname) + 2;
      75                 :            :         }
      76                 :            : 
      77                 :          0 :         return aa_hidden_ns_name;
      78                 :            : }
      79                 :            : 
      80                 :            : /**
      81                 :            :  * alloc_ns - allocate, initialize and return a new namespace
      82                 :            :  * @prefix: parent namespace name (MAYBE NULL)
      83                 :            :  * @name: a preallocated name  (NOT NULL)
      84                 :            :  *
      85                 :            :  * Returns: refcounted namespace or NULL on failure.
      86                 :            :  */
      87                 :          0 : static struct aa_ns *alloc_ns(const char *prefix, const char *name)
      88                 :            : {
      89                 :            :         struct aa_ns *ns;
      90                 :            : 
      91                 :          0 :         ns = kzalloc(sizeof(*ns), GFP_KERNEL);
      92                 :            :         AA_DEBUG("%s(%p)\n", __func__, ns);
      93                 :          0 :         if (!ns)
      94                 :            :                 return NULL;
      95                 :          0 :         if (!aa_policy_init(&ns->base, prefix, name, GFP_KERNEL))
      96                 :            :                 goto fail_ns;
      97                 :            : 
      98                 :          0 :         INIT_LIST_HEAD(&ns->sub_ns);
      99                 :          0 :         INIT_LIST_HEAD(&ns->rawdata_list);
     100                 :          0 :         mutex_init(&ns->lock);
     101                 :          0 :         init_waitqueue_head(&ns->wait);
     102                 :            : 
     103                 :            :         /* released by aa_free_ns() */
     104                 :          0 :         ns->unconfined = aa_alloc_profile("unconfined", NULL, GFP_KERNEL);
     105                 :          0 :         if (!ns->unconfined)
     106                 :            :                 goto fail_unconfined;
     107                 :            : 
     108                 :          0 :         ns->unconfined->label.flags |= FLAG_IX_ON_NAME_ERROR |
     109                 :            :                 FLAG_IMMUTIBLE | FLAG_NS_COUNT | FLAG_UNCONFINED;
     110                 :          0 :         ns->unconfined->mode = APPARMOR_UNCONFINED;
     111                 :          0 :         ns->unconfined->file.dfa = aa_get_dfa(nulldfa);
     112                 :          0 :         ns->unconfined->policy.dfa = aa_get_dfa(nulldfa);
     113                 :            : 
     114                 :            :         /* ns and ns->unconfined share ns->unconfined refcount */
     115                 :          0 :         ns->unconfined->ns = ns;
     116                 :            : 
     117                 :            :         atomic_set(&ns->uniq_null, 0);
     118                 :            : 
     119                 :          0 :         aa_labelset_init(&ns->labels);
     120                 :            : 
     121                 :          0 :         return ns;
     122                 :            : 
     123                 :            : fail_unconfined:
     124                 :          0 :         kzfree(ns->base.hname);
     125                 :            : fail_ns:
     126                 :          0 :         kzfree(ns);
     127                 :          0 :         return NULL;
     128                 :            : }
     129                 :            : 
     130                 :            : /**
     131                 :            :  * aa_free_ns - free a profile namespace
     132                 :            :  * @ns: the namespace to free  (MAYBE NULL)
     133                 :            :  *
     134                 :            :  * Requires: All references to the namespace must have been put, if the
     135                 :            :  *           namespace was referenced by a profile confining a task,
     136                 :            :  */
     137                 :          0 : void aa_free_ns(struct aa_ns *ns)
     138                 :            : {
     139                 :          0 :         if (!ns)
     140                 :          0 :                 return;
     141                 :            : 
     142                 :          0 :         aa_policy_destroy(&ns->base);
     143                 :          0 :         aa_labelset_destroy(&ns->labels);
     144                 :          0 :         aa_put_ns(ns->parent);
     145                 :            : 
     146                 :          0 :         ns->unconfined->ns = NULL;
     147                 :          0 :         aa_free_profile(ns->unconfined);
     148                 :          0 :         kzfree(ns);
     149                 :            : }
     150                 :            : 
     151                 :            : /**
     152                 :            :  * aa_findn_ns  -  look up a profile namespace on the namespace list
     153                 :            :  * @root: namespace to search in  (NOT NULL)
     154                 :            :  * @name: name of namespace to find  (NOT NULL)
     155                 :            :  * @n: length of @name
     156                 :            :  *
     157                 :            :  * Returns: a refcounted namespace on the list, or NULL if no namespace
     158                 :            :  *          called @name exists.
     159                 :            :  *
     160                 :            :  * refcount released by caller
     161                 :            :  */
     162                 :          0 : struct aa_ns *aa_findn_ns(struct aa_ns *root, const char *name, size_t n)
     163                 :            : {
     164                 :            :         struct aa_ns *ns = NULL;
     165                 :            : 
     166                 :            :         rcu_read_lock();
     167                 :          0 :         ns = aa_get_ns(__aa_findn_ns(&root->sub_ns, name, n));
     168                 :            :         rcu_read_unlock();
     169                 :            : 
     170                 :          0 :         return ns;
     171                 :            : }
     172                 :            : 
     173                 :            : /**
     174                 :            :  * aa_find_ns  -  look up a profile namespace on the namespace list
     175                 :            :  * @root: namespace to search in  (NOT NULL)
     176                 :            :  * @name: name of namespace to find  (NOT NULL)
     177                 :            :  *
     178                 :            :  * Returns: a refcounted namespace on the list, or NULL if no namespace
     179                 :            :  *          called @name exists.
     180                 :            :  *
     181                 :            :  * refcount released by caller
     182                 :            :  */
     183                 :          0 : struct aa_ns *aa_find_ns(struct aa_ns *root, const char *name)
     184                 :            : {
     185                 :          0 :         return aa_findn_ns(root, name, strlen(name));
     186                 :            : }
     187                 :            : 
     188                 :            : /**
     189                 :            :  * __aa_lookupn_ns - lookup the namespace matching @hname
     190                 :            :  * @base: base list to start looking up profile name from  (NOT NULL)
     191                 :            :  * @hname: hierarchical ns name  (NOT NULL)
     192                 :            :  * @n: length of @hname
     193                 :            :  *
     194                 :            :  * Requires: rcu_read_lock be held
     195                 :            :  *
     196                 :            :  * Returns: unrefcounted ns pointer or NULL if not found
     197                 :            :  *
     198                 :            :  * Do a relative name lookup, recursing through profile tree.
     199                 :            :  */
     200                 :          0 : struct aa_ns *__aa_lookupn_ns(struct aa_ns *view, const char *hname, size_t n)
     201                 :            : {
     202                 :            :         struct aa_ns *ns = view;
     203                 :            :         const char *split;
     204                 :            : 
     205                 :          0 :         for (split = strnstr(hname, "//", n); split;
     206                 :          0 :              split = strnstr(hname, "//", n)) {
     207                 :          0 :                 ns = __aa_findn_ns(&ns->sub_ns, hname, split - hname);
     208                 :          0 :                 if (!ns)
     209                 :            :                         return NULL;
     210                 :            : 
     211                 :          0 :                 n -= split + 2 - hname;
     212                 :            :                 hname = split + 2;
     213                 :            :         }
     214                 :            : 
     215                 :          0 :         if (n)
     216                 :          0 :                 return __aa_findn_ns(&ns->sub_ns, hname, n);
     217                 :            :         return NULL;
     218                 :            : }
     219                 :            : 
     220                 :            : /**
     221                 :            :  * aa_lookupn_ns  -  look up a policy namespace relative to @view
     222                 :            :  * @view: namespace to search in  (NOT NULL)
     223                 :            :  * @name: name of namespace to find  (NOT NULL)
     224                 :            :  * @n: length of @name
     225                 :            :  *
     226                 :            :  * Returns: a refcounted namespace on the list, or NULL if no namespace
     227                 :            :  *          called @name exists.
     228                 :            :  *
     229                 :            :  * refcount released by caller
     230                 :            :  */
     231                 :          0 : struct aa_ns *aa_lookupn_ns(struct aa_ns *view, const char *name, size_t n)
     232                 :            : {
     233                 :            :         struct aa_ns *ns = NULL;
     234                 :            : 
     235                 :            :         rcu_read_lock();
     236                 :          0 :         ns = aa_get_ns(__aa_lookupn_ns(view, name, n));
     237                 :            :         rcu_read_unlock();
     238                 :            : 
     239                 :          0 :         return ns;
     240                 :            : }
     241                 :            : 
     242                 :          0 : static struct aa_ns *__aa_create_ns(struct aa_ns *parent, const char *name,
     243                 :            :                                     struct dentry *dir)
     244                 :            : {
     245                 :            :         struct aa_ns *ns;
     246                 :            :         int error;
     247                 :            : 
     248                 :            :         AA_BUG(!parent);
     249                 :            :         AA_BUG(!name);
     250                 :            :         AA_BUG(!mutex_is_locked(&parent->lock));
     251                 :            : 
     252                 :          0 :         ns = alloc_ns(parent->base.hname, name);
     253                 :          0 :         if (!ns)
     254                 :            :                 return ERR_PTR(-ENOMEM);
     255                 :          0 :         ns->level = parent->level + 1;
     256                 :          0 :         mutex_lock_nested(&ns->lock, ns->level);
     257                 :          0 :         error = __aafs_ns_mkdir(ns, ns_subns_dir(parent), name, dir);
     258                 :          0 :         if (error) {
     259                 :          0 :                 AA_ERROR("Failed to create interface for ns %s\n",
     260                 :            :                          ns->base.name);
     261                 :          0 :                 mutex_unlock(&ns->lock);
     262                 :          0 :                 aa_free_ns(ns);
     263                 :          0 :                 return ERR_PTR(error);
     264                 :            :         }
     265                 :          0 :         ns->parent = aa_get_ns(parent);
     266                 :          0 :         list_add_rcu(&ns->base.list, &parent->sub_ns);
     267                 :            :         /* add list ref */
     268                 :            :         aa_get_ns(ns);
     269                 :          0 :         mutex_unlock(&ns->lock);
     270                 :            : 
     271                 :          0 :         return ns;
     272                 :            : }
     273                 :            : 
     274                 :            : /**
     275                 :            :  * aa_create_ns - create an ns, fail if it already exists
     276                 :            :  * @parent: the parent of the namespace being created
     277                 :            :  * @name: the name of the namespace
     278                 :            :  * @dir: if not null the dir to put the ns entries in
     279                 :            :  *
     280                 :            :  * Returns: the a refcounted ns that has been add or an ERR_PTR
     281                 :            :  */
     282                 :          0 : struct aa_ns *__aa_find_or_create_ns(struct aa_ns *parent, const char *name,
     283                 :            :                                      struct dentry *dir)
     284                 :            : {
     285                 :            :         struct aa_ns *ns;
     286                 :            : 
     287                 :            :         AA_BUG(!mutex_is_locked(&parent->lock));
     288                 :            : 
     289                 :            :         /* try and find the specified ns */
     290                 :            :         /* released by caller */
     291                 :          0 :         ns = aa_get_ns(__aa_find_ns(&parent->sub_ns, name));
     292                 :          0 :         if (!ns)
     293                 :          0 :                 ns = __aa_create_ns(parent, name, dir);
     294                 :            :         else
     295                 :            :                 ns = ERR_PTR(-EEXIST);
     296                 :            : 
     297                 :            :         /* return ref */
     298                 :          0 :         return ns;
     299                 :            : }
     300                 :            : 
     301                 :            : /**
     302                 :            :  * aa_prepare_ns - find an existing or create a new namespace of @name
     303                 :            :  * @parent: ns to treat as parent
     304                 :            :  * @name: the namespace to find or add  (NOT NULL)
     305                 :            :  *
     306                 :            :  * Returns: refcounted namespace or PTR_ERR if failed to create one
     307                 :            :  */
     308                 :          0 : struct aa_ns *aa_prepare_ns(struct aa_ns *parent, const char *name)
     309                 :            : {
     310                 :            :         struct aa_ns *ns;
     311                 :            : 
     312                 :          0 :         mutex_lock_nested(&parent->lock, parent->level);
     313                 :            :         /* try and find the specified ns and if it doesn't exist create it */
     314                 :            :         /* released by caller */
     315                 :          0 :         ns = aa_get_ns(__aa_find_ns(&parent->sub_ns, name));
     316                 :          0 :         if (!ns)
     317                 :          0 :                 ns = __aa_create_ns(parent, name, NULL);
     318                 :          0 :         mutex_unlock(&parent->lock);
     319                 :            : 
     320                 :            :         /* return ref */
     321                 :          0 :         return ns;
     322                 :            : }
     323                 :            : 
     324                 :            : static void __ns_list_release(struct list_head *head);
     325                 :            : 
     326                 :            : /**
     327                 :            :  * destroy_ns - remove everything contained by @ns
     328                 :            :  * @ns: namespace to have it contents removed  (NOT NULL)
     329                 :            :  */
     330                 :          0 : static void destroy_ns(struct aa_ns *ns)
     331                 :            : {
     332                 :          0 :         if (!ns)
     333                 :          0 :                 return;
     334                 :            : 
     335                 :          0 :         mutex_lock_nested(&ns->lock, ns->level);
     336                 :            :         /* release all profiles in this namespace */
     337                 :          0 :         __aa_profile_list_release(&ns->base.profiles);
     338                 :            : 
     339                 :            :         /* release all sub namespaces */
     340                 :          0 :         __ns_list_release(&ns->sub_ns);
     341                 :            : 
     342                 :          0 :         if (ns->parent) {
     343                 :            :                 unsigned long flags;
     344                 :            : 
     345                 :          0 :                 write_lock_irqsave(&ns->labels.lock, flags);
     346                 :          0 :                 __aa_proxy_redirect(ns_unconfined(ns),
     347                 :          0 :                                     ns_unconfined(ns->parent));
     348                 :          0 :                 write_unlock_irqrestore(&ns->labels.lock, flags);
     349                 :            :         }
     350                 :          0 :         __aafs_ns_rmdir(ns);
     351                 :          0 :         mutex_unlock(&ns->lock);
     352                 :            : }
     353                 :            : 
     354                 :            : /**
     355                 :            :  * __aa_remove_ns - remove a namespace and all its children
     356                 :            :  * @ns: namespace to be removed  (NOT NULL)
     357                 :            :  *
     358                 :            :  * Requires: ns->parent->lock be held and ns removed from parent.
     359                 :            :  */
     360                 :          0 : void __aa_remove_ns(struct aa_ns *ns)
     361                 :            : {
     362                 :            :         /* remove ns from namespace list */
     363                 :            :         list_del_rcu(&ns->base.list);
     364                 :          0 :         destroy_ns(ns);
     365                 :          0 :         aa_put_ns(ns);
     366                 :          0 : }
     367                 :            : 
     368                 :            : /**
     369                 :            :  * __ns_list_release - remove all profile namespaces on the list put refs
     370                 :            :  * @head: list of profile namespaces  (NOT NULL)
     371                 :            :  *
     372                 :            :  * Requires: namespace lock be held
     373                 :            :  */
     374                 :          0 : static void __ns_list_release(struct list_head *head)
     375                 :            : {
     376                 :            :         struct aa_ns *ns, *tmp;
     377                 :            : 
     378                 :          0 :         list_for_each_entry_safe(ns, tmp, head, base.list)
     379                 :          0 :                 __aa_remove_ns(ns);
     380                 :            : 
     381                 :          0 : }
     382                 :            : 
     383                 :            : /**
     384                 :            :  * aa_alloc_root_ns - allocate the root profile namespace
     385                 :            :  *
     386                 :            :  * Returns: %0 on success else error
     387                 :            :  *
     388                 :            :  */
     389                 :          0 : int __init aa_alloc_root_ns(void)
     390                 :            : {
     391                 :            :         /* released by aa_free_root_ns - used as list ref*/
     392                 :          0 :         root_ns = alloc_ns(NULL, "root");
     393                 :          0 :         if (!root_ns)
     394                 :            :                 return -ENOMEM;
     395                 :            : 
     396                 :          0 :         return 0;
     397                 :            : }
     398                 :            : 
     399                 :            :  /**
     400                 :            :   * aa_free_root_ns - free the root profile namespace
     401                 :            :   */
     402                 :          0 : void __init aa_free_root_ns(void)
     403                 :            : {
     404                 :          0 :          struct aa_ns *ns = root_ns;
     405                 :            : 
     406                 :          0 :          root_ns = NULL;
     407                 :            : 
     408                 :          0 :          destroy_ns(ns);
     409                 :          0 :          aa_put_ns(ns);
     410                 :          0 : }