~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/security/apparmor/path.c

Version: ~ [ linux-5.13-rc1 ] ~ [ linux-5.12.2 ] ~ [ linux-5.11.19 ] ~ [ linux-5.10.35 ] ~ [ linux-5.9.16 ] ~ [ linux-5.8.18 ] ~ [ linux-5.7.19 ] ~ [ linux-5.6.19 ] ~ [ linux-5.5.19 ] ~ [ linux-5.4.117 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.190 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.232 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.268 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.268 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.18.140 ] ~ [ linux-3.16.85 ] ~ [ linux-3.14.79 ] ~ [ linux-3.12.74 ] ~ [ linux-3.10.108 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

  1 /*
  2  * AppArmor security module
  3  *
  4  * This file contains AppArmor function for pathnames
  5  *
  6  * Copyright (C) 1998-2008 Novell/SUSE
  7  * Copyright 2009-2010 Canonical Ltd.
  8  *
  9  * This program is free software; you can redistribute it and/or
 10  * modify it under the terms of the GNU General Public License as
 11  * published by the Free Software Foundation, version 2 of the
 12  * License.
 13  */
 14 
 15 #include <linux/magic.h>
 16 #include <linux/mount.h>
 17 #include <linux/namei.h>
 18 #include <linux/nsproxy.h>
 19 #include <linux/path.h>
 20 #include <linux/sched.h>
 21 #include <linux/slab.h>
 22 #include <linux/fs_struct.h>
 23 
 24 #include "include/apparmor.h"
 25 #include "include/path.h"
 26 #include "include/policy.h"
 27 
 28 /* modified from dcache.c */
 29 static int prepend(char **buffer, int buflen, const char *str, int namelen)
 30 {
 31         buflen -= namelen;
 32         if (buflen < 0)
 33                 return -ENAMETOOLONG;
 34         *buffer -= namelen;
 35         memcpy(*buffer, str, namelen);
 36         return 0;
 37 }
 38 
 39 #define CHROOT_NSCONNECT (PATH_CHROOT_REL | PATH_CHROOT_NSCONNECT)
 40 
 41 /* If the path is not connected to the expected root,
 42  * check if it is a sysctl and handle specially else remove any
 43  * leading / that __d_path may have returned.
 44  * Unless
 45  *     specifically directed to connect the path,
 46  * OR
 47  *     if in a chroot and doing chroot relative paths and the path
 48  *     resolves to the namespace root (would be connected outside
 49  *     of chroot) and specifically directed to connect paths to
 50  *     namespace root.
 51  */
 52 static int disconnect(const struct path *path, char *buf, char **name,
 53                       int flags)
 54 {
 55         int error = 0;
 56 
 57         if (!(flags & PATH_CONNECT_PATH) &&
 58             !(((flags & CHROOT_NSCONNECT) == CHROOT_NSCONNECT) &&
 59               our_mnt(path->mnt))) {
 60                 /* disconnected path, don't return pathname starting
 61                  * with '/'
 62                  */
 63                 error = -EACCES;
 64                 if (**name == '/')
 65                         *name = *name + 1;
 66         } else if (**name != '/')
 67                 /* CONNECT_PATH with missing root */
 68                 error = prepend(name, *name - buf, "/", 1);
 69 
 70         return error;
 71 }
 72 
 73 /**
 74  * d_namespace_path - lookup a name associated with a given path
 75  * @path: path to lookup  (NOT NULL)
 76  * @buf:  buffer to store path to  (NOT NULL)
 77  * @buflen: length of @buf
 78  * @name: Returns - pointer for start of path name with in @buf (NOT NULL)
 79  * @flags: flags controlling path lookup
 80  *
 81  * Handle path name lookup.
 82  *
 83  * Returns: %0 else error code if path lookup fails
 84  *          When no error the path name is returned in @name which points to
 85  *          to a position in @buf
 86  */
 87 static int d_namespace_path(struct path *path, char *buf, int buflen,
 88                             char **name, int flags)
 89 {
 90         char *res;
 91         int error = 0;
 92         int connected = 1;
 93 
 94         if (path->mnt->mnt_flags & MNT_INTERNAL) {
 95                 /* it's not mounted anywhere */
 96                 res = dentry_path(path->dentry, buf, buflen);
 97                 *name = res;
 98                 if (IS_ERR(res)) {
 99                         *name = buf;
100                         return PTR_ERR(res);
101                 }
102                 if (path->dentry->d_sb->s_magic == PROC_SUPER_MAGIC &&
103                     strncmp(*name, "/sys/", 5) == 0) {
104                         /* TODO: convert over to using a per namespace
105                          * control instead of hard coded /proc
106                          */
107                         return prepend(name, *name - buf, "/proc", 5);
108                 } else
109                         return disconnect(path, buf, name, flags);
110                 return 0;
111         }
112 
113         /* resolve paths relative to chroot?*/
114         if (flags & PATH_CHROOT_REL) {
115                 struct path root;
116                 get_fs_root(current->fs, &root);
117                 res = __d_path(path, &root, buf, buflen);
118                 path_put(&root);
119         } else {
120                 res = d_absolute_path(path, buf, buflen);
121                 if (!our_mnt(path->mnt))
122                         connected = 0;
123         }
124 
125         /* handle error conditions - and still allow a partial path to
126          * be returned.
127          */
128         if (!res || IS_ERR(res)) {
129                 if (PTR_ERR(res) == -ENAMETOOLONG)
130                         return -ENAMETOOLONG;
131                 connected = 0;
132                 res = dentry_path_raw(path->dentry, buf, buflen);
133                 if (IS_ERR(res)) {
134                         error = PTR_ERR(res);
135                         *name = buf;
136                         goto out;
137                 };
138         } else if (!our_mnt(path->mnt))
139                 connected = 0;
140 
141         *name = res;
142 
143         /* Handle two cases:
144          * 1. A deleted dentry && profile is not allowing mediation of deleted
145          * 2. On some filesystems, newly allocated dentries appear to the
146          *    security_path hooks as a deleted dentry except without an inode
147          *    allocated.
148          */
149         if (d_unlinked(path->dentry) && path->dentry->d_inode &&
150             !(flags & PATH_MEDIATE_DELETED)) {
151                         error = -ENOENT;
152                         goto out;
153         }
154 
155         if (!connected)
156                 error = disconnect(path, buf, name, flags);
157 
158 out:
159         return error;
160 }
161 
162 /**
163  * get_name_to_buffer - get the pathname to a buffer ensure dir / is appended
164  * @path: path to get name for  (NOT NULL)
165  * @flags: flags controlling path lookup
166  * @buffer: buffer to put name in  (NOT NULL)
167  * @size: size of buffer
168  * @name: Returns - contains position of path name in @buffer (NOT NULL)
169  *
170  * Returns: %0 else error on failure
171  */
172 static int get_name_to_buffer(struct path *path, int flags, char *buffer,
173                               int size, char **name, const char **info)
174 {
175         int adjust = (flags & PATH_IS_DIR) ? 1 : 0;
176         int error = d_namespace_path(path, buffer, size - adjust, name, flags);
177 
178         if (!error && (flags & PATH_IS_DIR) && (*name)[1] != '\0')
179                 /*
180                  * Append "/" to the pathname.  The root directory is a special
181                  * case; it already ends in slash.
182                  */
183                 strcpy(&buffer[size - 2], "/");
184 
185         if (info && error) {
186                 if (error == -ENOENT)
187                         *info = "Failed name lookup - deleted entry";
188                 else if (error == -EACCES)
189                         *info = "Failed name lookup - disconnected path";
190                 else if (error == -ENAMETOOLONG)
191                         *info = "Failed name lookup - name too long";
192                 else
193                         *info = "Failed name lookup";
194         }
195 
196         return error;
197 }
198 
199 /**
200  * aa_path_name - compute the pathname of a file
201  * @path: path the file  (NOT NULL)
202  * @flags: flags controlling path name generation
203  * @buffer: buffer that aa_get_name() allocated  (NOT NULL)
204  * @name: Returns - the generated path name if !error (NOT NULL)
205  * @info: Returns - information on why the path lookup failed (MAYBE NULL)
206  *
207  * @name is a pointer to the beginning of the pathname (which usually differs
208  * from the beginning of the buffer), or NULL.  If there is an error @name
209  * may contain a partial or invalid name that can be used for audit purposes,
210  * but it can not be used for mediation.
211  *
212  * We need PATH_IS_DIR to indicate whether the file is a directory or not
213  * because the file may not yet exist, and so we cannot check the inode's
214  * file type.
215  *
216  * Returns: %0 else error code if could retrieve name
217  */
218 int aa_path_name(struct path *path, int flags, char **buffer, const char **name,
219                  const char **info)
220 {
221         char *buf, *str = NULL;
222         int size = 256;
223         int error;
224 
225         *name = NULL;
226         *buffer = NULL;
227         for (;;) {
228                 /* freed by caller */
229                 buf = kmalloc(size, GFP_KERNEL);
230                 if (!buf)
231                         return -ENOMEM;
232 
233                 error = get_name_to_buffer(path, flags, buf, size, &str, info);
234                 if (error != -ENAMETOOLONG)
235                         break;
236 
237                 kfree(buf);
238                 size <<= 1;
239                 if (size > aa_g_path_max)
240                         return -ENAMETOOLONG;
241                 *info = NULL;
242         }
243         *buffer = buf;
244         *name = str;
245 
246         return error;
247 }
248 

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp