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, const char *disconnected) 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 { 67 if (**name != '/') 68 /* CONNECT_PATH with missing root */ 69 error = prepend(name, *name - buf, "/", 1); 70 if (!error && disconnected) 71 error = prepend(name, *name - buf, disconnected, 72 strlen(disconnected)); 73 } 74 75 return error; 76 } 77 78 /** 79 * d_namespace_path - lookup a name associated with a given path 80 * @path: path to lookup (NOT NULL) 81 * @buf: buffer to store path to (NOT NULL) 82 * @buflen: length of @buf 83 * @name: Returns - pointer for start of path name with in @buf (NOT NULL) 84 * @flags: flags controlling path lookup 85 * @disconnected: string to prefix to disconnected paths 86 * 87 * Handle path name lookup. 88 * 89 * Returns: %0 else error code if path lookup fails 90 * When no error the path name is returned in @name which points to 91 * to a position in @buf 92 */ 93 static int d_namespace_path(const struct path *path, char *buf, int buflen, 94 char **name, int flags, const char *disconnected) 95 { 96 char *res; 97 int error = 0; 98 int connected = 1; 99 100 if (path->mnt->mnt_flags & MNT_INTERNAL) { 101 /* it's not mounted anywhere */ 102 res = dentry_path(path->dentry, buf, buflen); 103 *name = res; 104 if (IS_ERR(res)) { 105 *name = buf; 106 return PTR_ERR(res); 107 } 108 if (path->dentry->d_sb->s_magic == PROC_SUPER_MAGIC && 109 strncmp(*name, "/sys/", 5) == 0) { 110 /* TODO: convert over to using a per namespace 111 * control instead of hard coded /proc 112 */ 113 return prepend(name, *name - buf, "/proc", 5); 114 } else 115 return disconnect(path, buf, name, flags, 116 disconnected); 117 } 118 119 /* resolve paths relative to chroot?*/ 120 if (flags & PATH_CHROOT_REL) { 121 struct path root; 122 get_fs_root(current->fs, &root); 123 res = __d_path(path, &root, buf, buflen); 124 path_put(&root); 125 } else { 126 res = d_absolute_path(path, buf, buflen); 127 if (!our_mnt(path->mnt)) 128 connected = 0; 129 } 130 131 /* handle error conditions - and still allow a partial path to 132 * be returned. 133 */ 134 if (!res || IS_ERR(res)) { 135 if (PTR_ERR(res) == -ENAMETOOLONG) 136 return -ENAMETOOLONG; 137 connected = 0; 138 res = dentry_path_raw(path->dentry, buf, buflen); 139 if (IS_ERR(res)) { 140 error = PTR_ERR(res); 141 *name = buf; 142 goto out; 143 }; 144 } else if (!our_mnt(path->mnt)) 145 connected = 0; 146 147 *name = res; 148 149 /* Handle two cases: 150 * 1. A deleted dentry && profile is not allowing mediation of deleted 151 * 2. On some filesystems, newly allocated dentries appear to the 152 * security_path hooks as a deleted dentry except without an inode 153 * allocated. 154 */ 155 if (d_unlinked(path->dentry) && d_is_positive(path->dentry) && 156 !(flags & PATH_MEDIATE_DELETED)) { 157 error = -ENOENT; 158 goto out; 159 } 160 161 if (!connected) 162 error = disconnect(path, buf, name, flags, disconnected); 163 164 out: 165 return error; 166 } 167 168 /** 169 * get_name_to_buffer - get the pathname to a buffer ensure dir / is appended 170 * @path: path to get name for (NOT NULL) 171 * @flags: flags controlling path lookup 172 * @buffer: buffer to put name in (NOT NULL) 173 * @size: size of buffer 174 * @name: Returns - contains position of path name in @buffer (NOT NULL) 175 * 176 * Returns: %0 else error on failure 177 */ 178 static int get_name_to_buffer(const struct path *path, int flags, char *buffer, 179 int size, char **name, const char **info, 180 const char *disconnected) 181 { 182 int adjust = (flags & PATH_IS_DIR) ? 1 : 0; 183 int error = d_namespace_path(path, buffer, size - adjust, name, flags, 184 disconnected); 185 186 if (!error && (flags & PATH_IS_DIR) && (*name)[1] != '\0') 187 /* 188 * Append "/" to the pathname. The root directory is a special 189 * case; it already ends in slash. 190 */ 191 strcpy(&buffer[size - 2], "/"); 192 193 if (info && error) { 194 if (error == -ENOENT) 195 *info = "Failed name lookup - deleted entry"; 196 else if (error == -EACCES) 197 *info = "Failed name lookup - disconnected path"; 198 else if (error == -ENAMETOOLONG) 199 *info = "Failed name lookup - name too long"; 200 else 201 *info = "Failed name lookup"; 202 } 203 204 return error; 205 } 206 207 /** 208 * aa_path_name - compute the pathname of a file 209 * @path: path the file (NOT NULL) 210 * @flags: flags controlling path name generation 211 * @buffer: buffer that aa_get_name() allocated (NOT NULL) 212 * @name: Returns - the generated path name if !error (NOT NULL) 213 * @info: Returns - information on why the path lookup failed (MAYBE NULL) 214 * @disconnected: string to prepend to disconnected paths 215 * 216 * @name is a pointer to the beginning of the pathname (which usually differs 217 * from the beginning of the buffer), or NULL. If there is an error @name 218 * may contain a partial or invalid name that can be used for audit purposes, 219 * but it can not be used for mediation. 220 * 221 * We need PATH_IS_DIR to indicate whether the file is a directory or not 222 * because the file may not yet exist, and so we cannot check the inode's 223 * file type. 224 * 225 * Returns: %0 else error code if could retrieve name 226 */ 227 int aa_path_name(const struct path *path, int flags, char **buffer, 228 const char **name, const char **info, const char *disconnected) 229 { 230 char *buf, *str = NULL; 231 int size = 256; 232 int error; 233 234 *name = NULL; 235 *buffer = NULL; 236 for (;;) { 237 /* freed by caller */ 238 buf = kmalloc(size, GFP_KERNEL); 239 if (!buf) 240 return -ENOMEM; 241 242 error = get_name_to_buffer(path, flags, buf, size, &str, info, 243 disconnected); 244 if (error != -ENAMETOOLONG) 245 break; 246 247 kfree(buf); 248 size <<= 1; 249 if (size > aa_g_path_max) 250 return -ENAMETOOLONG; 251 *info = NULL; 252 } 253 *buffer = buf; 254 *name = str; 255 256 return error; 257 } 258