SAFE public projects git trees. - safe/jmp/linux-2.6/blob - security/tomoyo/realpath.c

   1 /*
   2  * security/tomoyo/realpath.c
   3  *
   4  * Get the canonicalized absolute pathnames. The basis for TOMOYO.
   5  *
   6  * Copyright (C) 2005-2009  NTT DATA CORPORATION
   7  *
   8  * Version: 2.2.0   2009/04/01
   9  *
  10  */
  11
  12 #include <linux/types.h>
  13 #include <linux/mount.h>
  14 #include <linux/mnt_namespace.h>
  15 #include <linux/fs_struct.h>
  16 #include <linux/hash.h>
  17 #include <linux/magic.h>
  18 #include "common.h"
  19
  20 /**
  21  * tomoyo_encode: Convert binary string to ascii string.
  22  *
  23  * @buffer:  Buffer for ASCII string.
  24  * @buflen:  Size of @buffer.
  25  * @str:     Binary string.
  26  *
  27  * Returns 0 on success, -ENOMEM otherwise.
  28  */
  29 int tomoyo_encode(char *buffer, int buflen, const char *str)
  30 {
  31         while (1) {
  32                 const unsigned char c = *(unsigned char *) str++;
  33
  34                 if (tomoyo_is_valid(c)) {
  35                         if (--buflen <= 0)
  36                                 break;
  37                         *buffer++ = (char) c;
  38                         if (c != '\\')
  39                                 continue;
  40                         if (--buflen <= 0)
  41                                 break;
  42                         *buffer++ = (char) c;
  43                         continue;
  44                 }
  45                 if (!c) {
  46                         if (--buflen <= 0)
  47                                 break;
  48                         *buffer = '\0';
  49                         return 0;
  50                 }
  51                 buflen -= 4;
  52                 if (buflen <= 0)
  53                         break;
  54                 *buffer++ = '\\';
  55                 *buffer++ = (c >> 6) + '0';
  56                 *buffer++ = ((c >> 3) & 7) + '0';
  57                 *buffer++ = (c & 7) + '0';
  58         }
  59         return -ENOMEM;
  60 }
  61
  62 /**
  63  * tomoyo_realpath_from_path2 - Returns realpath(3) of the given dentry but ignores chroot'ed root.
  64  *
  65  * @path:        Pointer to "struct path".
  66  * @newname:     Pointer to buffer to return value in.
  67  * @newname_len: Size of @newname.
  68  *
  69  * Returns 0 on success, negative value otherwise.
  70  *
  71  * If dentry is a directory, trailing '/' is appended.
  72  * Characters out of 0x20 < c < 0x7F range are converted to
  73  * \ooo style octal string.
  74  * Character \ is converted to \\ string.
  75  */
  76 int tomoyo_realpath_from_path2(struct path *path, char *newname,
  77                                int newname_len)
  78 {
  79         int error = -ENOMEM;
  80         struct dentry *dentry = path->dentry;
  81         char *sp;
  82
  83         if (!dentry || !path->mnt || !newname || newname_len <= 2048)
  84                 return -EINVAL;
  85         if (dentry->d_op && dentry->d_op->d_dname) {
  86                 /* For "socket:[\$]" and "pipe:[\$]". */
  87                 static const int offset = 1536;
  88                 sp = dentry->d_op->d_dname(dentry, newname + offset,
  89                                            newname_len - offset);
  90         } else {
  91                 /* Taken from d_namespace_path(). */
  92                 struct path root;
  93                 struct path ns_root = { };
  94                 struct path tmp;
  95
  96                 read_lock(&current->fs->lock);
  97                 root = current->fs->root;
  98                 path_get(&root);
  99                 read_unlock(&current->fs->lock);
 100                 spin_lock(&vfsmount_lock);
 101                 if (root.mnt && root.mnt->mnt_ns)
 102                         ns_root.mnt = mntget(root.mnt->mnt_ns->root);
 103                 if (ns_root.mnt)
 104                         ns_root.dentry = dget(ns_root.mnt->mnt_root);
 105                 spin_unlock(&vfsmount_lock);
 106                 spin_lock(&dcache_lock);
 107                 tmp = ns_root;
 108                 sp = __d_path(path, &tmp, newname, newname_len);
 109                 spin_unlock(&dcache_lock);
 110                 path_put(&root);
 111                 path_put(&ns_root);
 112                 /* Prepend "/proc" prefix if using internal proc vfs mount. */
 113                 if (!IS_ERR(sp) && (path->mnt->mnt_parent == path->mnt) &&
 114                     (path->mnt->mnt_sb->s_magic == PROC_SUPER_MAGIC)) {
 115                         sp -= 5;
 116                         if (sp >= newname)
 117                                 memcpy(sp, "/proc", 5);
 118                         else
 119                                 sp = ERR_PTR(-ENOMEM);
 120                 }
 121         }
 122         if (IS_ERR(sp))
 123                 error = PTR_ERR(sp);
 124         else
 125                 error = tomoyo_encode(newname, sp - newname, sp);
 126         /* Append trailing '/' if dentry is a directory. */
 127         if (!error && dentry->d_inode && S_ISDIR(dentry->d_inode->i_mode)
 128             && *newname) {
 129                 sp = newname + strlen(newname);
 130                 if (*(sp - 1) != '/') {
 131                         if (sp < newname + newname_len - 4) {
 132                                 *sp++ = '/';
 133                                 *sp = '\0';
 134                         } else {
 135                                 error = -ENOMEM;
 136                         }
 137                 }
 138         }
 139         if (error)
 140                 printk(KERN_WARNING "tomoyo_realpath: Pathname too long.\n");
 141         return error;
 142 }
 143
 144 /**
 145  * tomoyo_realpath_from_path - Returns realpath(3) of the given pathname but ignores chroot'ed root.
 146  *
 147  * @path: Pointer to "struct path".
 148  *
 149  * Returns the realpath of the given @path on success, NULL otherwise.
 150  *
 151  * These functions use kzalloc(), so the caller must call kfree()
 152  * if these functions didn't return NULL.
 153  */
 154 char *tomoyo_realpath_from_path(struct path *path)
 155 {
 156         char *buf = kzalloc(sizeof(struct tomoyo_page_buffer), GFP_KERNEL);
 157
 158         BUILD_BUG_ON(sizeof(struct tomoyo_page_buffer)
 159                      <= TOMOYO_MAX_PATHNAME_LEN - 1);
 160         if (!buf)
 161                 return NULL;
 162         if (tomoyo_realpath_from_path2(path, buf,
 163                                        TOMOYO_MAX_PATHNAME_LEN - 1) == 0)
 164                 return buf;
 165         kfree(buf);
 166         return NULL;
 167 }
 168
 169 /**
 170  * tomoyo_realpath - Get realpath of a pathname.
 171  *
 172  * @pathname: The pathname to solve.
 173  *
 174  * Returns the realpath of @pathname on success, NULL otherwise.
 175  */
 176 char *tomoyo_realpath(const char *pathname)
 177 {
 178         struct path path;
 179
 180         if (pathname && kern_path(pathname, LOOKUP_FOLLOW, &path) == 0) {
 181                 char *buf = tomoyo_realpath_from_path(&path);
 182                 path_put(&path);
 183                 return buf;
 184         }
 185         return NULL;
 186 }
 187
 188 /**
 189  * tomoyo_realpath_nofollow - Get realpath of a pathname.
 190  *
 191  * @pathname: The pathname to solve.
 192  *
 193  * Returns the realpath of @pathname on success, NULL otherwise.
 194  */
 195 char *tomoyo_realpath_nofollow(const char *pathname)
 196 {
 197         struct path path;
 198
 199         if (pathname && kern_path(pathname, 0, &path) == 0) {
 200                 char *buf = tomoyo_realpath_from_path(&path);
 201                 path_put(&path);
 202                 return buf;
 203         }
 204         return NULL;
 205 }
 206
 207 /* Memory allocated for non-string data. */
 208 static unsigned int tomoyo_allocated_memory_for_elements;
 209 /* Quota for holding non-string data. */
 210 static unsigned int tomoyo_quota_for_elements;
 211
 212 /**
 213  * tomoyo_memory_ok - Check memory quota.
 214  *
 215  * @ptr: Pointer to allocated memory.
 216  *
 217  * Returns true on success, false otherwise.
 218  *
 219  * Caller holds tomoyo_policy_lock.
 220  * Memory pointed by @ptr will be zeroed on success.
 221  */
 222 bool tomoyo_memory_ok(void *ptr)
 223 {
 224         int allocated_len = ptr ? ksize(ptr) : 0;
 225         bool result = false;
 226         if (!ptr || (tomoyo_quota_for_elements &&
 227                      tomoyo_allocated_memory_for_elements
 228                      + allocated_len > tomoyo_quota_for_elements)) {
 229                 printk(KERN_WARNING "ERROR: Out of memory "
 230                        "for tomoyo_alloc_element().\n");
 231                 if (!tomoyo_policy_loaded)
 232                         panic("MAC Initialization failed.\n");
 233         } else {
 234                 result = true;
 235                 tomoyo_allocated_memory_for_elements += allocated_len;
 236                 memset(ptr, 0, allocated_len);
 237         }
 238         return result;
 239 }
 240
 241 /* Memory allocated for string data in bytes. */
 242 static unsigned int tomoyo_allocated_memory_for_savename;
 243 /* Quota for holding string data in bytes. */
 244 static unsigned int tomoyo_quota_for_savename;
 245
 246 /*
 247  * tomoyo_name_list is used for holding string data used by TOMOYO.
 248  * Since same string data is likely used for multiple times (e.g.
 249  * "/lib/libc-2.5.so"), TOMOYO shares string data in the form of
 250  * "const struct tomoyo_path_info *".
 251  */
 252 static struct list_head tomoyo_name_list[TOMOYO_MAX_HASH];
 253
 254 /**
 255  * tomoyo_get_name - Allocate permanent memory for string data.
 256  *
 257  * @name: The string to store into the permernent memory.
 258  *
 259  * Returns pointer to "struct tomoyo_path_info" on success, NULL otherwise.
 260  */
 261 const struct tomoyo_path_info *tomoyo_get_name(const char *name)
 262 {
 263         static DEFINE_MUTEX(lock);
 264         struct tomoyo_name_entry *ptr;
 265         unsigned int hash;
 266         int len;
 267         int allocated_len;
 268         struct list_head *head;
 269
 270         if (!name)
 271                 return NULL;
 272         len = strlen(name) + 1;
 273         hash = full_name_hash((const unsigned char *) name, len - 1);
 274         head = &tomoyo_name_list[hash_long(hash, TOMOYO_HASH_BITS)];
 275         mutex_lock(&lock);
 276         list_for_each_entry(ptr, head, list) {
 277                 if (hash != ptr->entry.hash || strcmp(name, ptr->entry.name))
 278                         continue;
 279                 atomic_inc(&ptr->users);
 280                 goto out;
 281         }
 282         ptr = kzalloc(sizeof(*ptr) + len, GFP_KERNEL);
 283         allocated_len = ptr ? ksize(ptr) : 0;
 284         if (!ptr || (tomoyo_quota_for_savename &&
 285                      tomoyo_allocated_memory_for_savename + allocated_len
 286                      > tomoyo_quota_for_savename)) {
 287                 kfree(ptr);
 288                 printk(KERN_WARNING "ERROR: Out of memory "
 289                        "for tomoyo_get_name().\n");
 290                 if (!tomoyo_policy_loaded)
 291                         panic("MAC Initialization failed.\n");
 292                 ptr = NULL;
 293                 goto out;
 294         }
 295         tomoyo_allocated_memory_for_savename += allocated_len;
 296         ptr->entry.name = ((char *) ptr) + sizeof(*ptr);
 297         memmove((char *) ptr->entry.name, name, len);
 298         atomic_set(&ptr->users, 1);
 299         tomoyo_fill_path_info(&ptr->entry);
 300         list_add_tail(&ptr->list, head);
 301  out:
 302         mutex_unlock(&lock);
 303         return ptr ? &ptr->entry : NULL;
 304 }
 305
 306 /**
 307  * tomoyo_realpath_init - Initialize realpath related code.
 308  */
 309 void __init tomoyo_realpath_init(void)
 310 {
 311         int i;
 312
 313         BUILD_BUG_ON(TOMOYO_MAX_PATHNAME_LEN > PATH_MAX);
 314         for (i = 0; i < TOMOYO_MAX_HASH; i++)
 315                 INIT_LIST_HEAD(&tomoyo_name_list[i]);
 316         INIT_LIST_HEAD(&tomoyo_kernel_domain.acl_info_list);
 317         tomoyo_kernel_domain.domainname = tomoyo_get_name(TOMOYO_ROOT_NAME);
 318         /*
 319          * tomoyo_read_lock() is not needed because this function is
 320          * called before the first "delete" request.
 321          */
 322         list_add_tail_rcu(&tomoyo_kernel_domain.list, &tomoyo_domain_list);
 323         if (tomoyo_find_domain(TOMOYO_ROOT_NAME) != &tomoyo_kernel_domain)
 324                 panic("Can't register tomoyo_kernel_domain");
 325 }
 326
 327 /**
 328  * tomoyo_read_memory_counter - Check for memory usage in bytes.
 329  *
 330  * @head: Pointer to "struct tomoyo_io_buffer".
 331  *
 332  * Returns memory usage.
 333  */
 334 int tomoyo_read_memory_counter(struct tomoyo_io_buffer *head)
 335 {
 336         if (!head->read_eof) {
 337                 const unsigned int shared
 338                         = tomoyo_allocated_memory_for_savename;
 339                 const unsigned int private
 340                         = tomoyo_allocated_memory_for_elements;
 341                 char buffer[64];
 342
 343                 memset(buffer, 0, sizeof(buffer));
 344                 if (tomoyo_quota_for_savename)
 345                         snprintf(buffer, sizeof(buffer) - 1,
 346                                  "   (Quota: %10u)",
 347                                  tomoyo_quota_for_savename);
 348                 else
 349                         buffer[0] = '\0';
 350                 tomoyo_io_printf(head, "Shared:  %10u%s\n", shared, buffer);
 351                 if (tomoyo_quota_for_elements)
 352                         snprintf(buffer, sizeof(buffer) - 1,
 353                                  "   (Quota: %10u)",
 354                                  tomoyo_quota_for_elements);
 355                 else
 356                         buffer[0] = '\0';
 357                 tomoyo_io_printf(head, "Private: %10u%s\n", private, buffer);
 358                 tomoyo_io_printf(head, "Total:   %10u\n", shared + private);
 359                 head->read_eof = true;
 360         }
 361         return 0;
 362 }
 363
 364 /**
 365  * tomoyo_write_memory_quota - Set memory quota.
 366  *
 367  * @head: Pointer to "struct tomoyo_io_buffer".
 368  *
 369  * Returns 0.
 370  */
 371 int tomoyo_write_memory_quota(struct tomoyo_io_buffer *head)
 372 {
 373         char *data = head->write_buf;
 374         unsigned int size;
 375
 376         if (sscanf(data, "Shared: %u", &size) == 1)
 377                 tomoyo_quota_for_savename = size;
 378         else if (sscanf(data, "Private: %u", &size) == 1)
 379                 tomoyo_quota_for_elements = size;
 380         return 0;
 381 }