security/tomoyo/realpath.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /*
   3  * security/tomoyo/realpath.c
   4  *
   5  * Copyright (C) 2005-2011  NTT DATA CORPORATION
   6  */
   7
   8 #include "common.h"
   9 #include <linux/magic.h>
  10 #include <linux/proc_fs.h>
  11
  12 /**
  13  * tomoyo_encode2 - Encode binary string to ascii string.
  14  *
  15  * @str:     String in binary format.
  16  * @str_len: Size of @str in byte.
  17  *
  18  * Returns pointer to @str in ascii format on success, NULL otherwise.
  19  *
  20  * This function uses kzalloc(), so caller must kfree() if this function
  21  * didn't return NULL.
  22  */
  23 char *tomoyo_encode2(const char *str, int str_len)
  24 {
  25         int i;
  26         int len = 0;
  27         const char *p = str;
  28         char *cp;
  29         char *cp0;
  30
  31         if (!p)
  32                 return NULL;
  33         for (i = 0; i < str_len; i++) {
  34                 const unsigned char c = p[i];
  35
  36                 if (c == '\\')
  37                         len += 2;
  38                 else if (c > ' ' && c < 127)
  39                         len++;
  40                 else
  41                         len += 4;
  42         }
  43         len++;
  44         /* Reserve space for appending "/". */
  45         cp = kzalloc(len + 10, GFP_NOFS);
  46         if (!cp)
  47                 return NULL;
  48         cp0 = cp;
  49         p = str;
  50         for (i = 0; i < str_len; i++) {
  51                 const unsigned char c = p[i];
  52
  53                 if (c == '\\') {
  54                         *cp++ = '\\';
  55                         *cp++ = '\\';
  56                 } else if (c > ' ' && c < 127) {
  57                         *cp++ = c;
  58                 } else {
  59                         *cp++ = '\\';
  60                         *cp++ = (c >> 6) + '0';
  61                         *cp++ = ((c >> 3) & 7) + '0';
  62                         *cp++ = (c & 7) + '0';
  63                 }
  64         }
  65         return cp0;
  66 }
  67
  68 /**
  69  * tomoyo_encode - Encode binary string to ascii string.
  70  *
  71  * @str: String in binary format.
  72  *
  73  * Returns pointer to @str in ascii format on success, NULL otherwise.
  74  *
  75  * This function uses kzalloc(), so caller must kfree() if this function
  76  * didn't return NULL.
  77  */
  78 char *tomoyo_encode(const char *str)
  79 {
  80         return str ? tomoyo_encode2(str, strlen(str)) : NULL;
  81 }
  82
  83 /**
  84  * tomoyo_get_absolute_path - Get the path of a dentry but ignores chroot'ed root.
  85  *
  86  * @path:   Pointer to "struct path".
  87  * @buffer: Pointer to buffer to return value in.
  88  * @buflen: Sizeof @buffer.
  89  *
  90  * Returns the buffer on success, an error code otherwise.
  91  *
  92  * If dentry is a directory, trailing '/' is appended.
  93  */
  94 static char *tomoyo_get_absolute_path(const struct path *path, char * const buffer,
  95                                       const int buflen)
  96 {
  97         char *pos = ERR_PTR(-ENOMEM);
  98
  99         if (buflen >= 256) {
 100                 /* go to whatever namespace root we are under */
 101                 pos = d_absolute_path(path, buffer, buflen - 1);
 102                 if (!IS_ERR(pos) && *pos == '/' && pos[1]) {
 103                         struct inode *inode = d_backing_inode(path->dentry);
 104
 105                         if (inode && S_ISDIR(inode->i_mode)) {
 106                                 buffer[buflen - 2] = '/';
 107                                 buffer[buflen - 1] = '\0';
 108                         }
 109                 }
 110         }
 111         return pos;
 112 }
 113
 114 /**
 115  * tomoyo_get_dentry_path - Get the path of a dentry.
 116  *
 117  * @dentry: Pointer to "struct dentry".
 118  * @buffer: Pointer to buffer to return value in.
 119  * @buflen: Sizeof @buffer.
 120  *
 121  * Returns the buffer on success, an error code otherwise.
 122  *
 123  * If dentry is a directory, trailing '/' is appended.
 124  */
 125 static char *tomoyo_get_dentry_path(struct dentry *dentry, char * const buffer,
 126                                     const int buflen)
 127 {
 128         char *pos = ERR_PTR(-ENOMEM);
 129
 130         if (buflen >= 256) {
 131                 pos = dentry_path_raw(dentry, buffer, buflen - 1);
 132                 if (!IS_ERR(pos) && *pos == '/' && pos[1]) {
 133                         struct inode *inode = d_backing_inode(dentry);
 134
 135                         if (inode && S_ISDIR(inode->i_mode)) {
 136                                 buffer[buflen - 2] = '/';
 137                                 buffer[buflen - 1] = '\0';
 138                         }
 139                 }
 140         }
 141         return pos;
 142 }
 143
 144 /**
 145  * tomoyo_get_local_path - Get the path of a dentry.
 146  *
 147  * @dentry: Pointer to "struct dentry".
 148  * @buffer: Pointer to buffer to return value in.
 149  * @buflen: Sizeof @buffer.
 150  *
 151  * Returns the buffer on success, an error code otherwise.
 152  */
 153 static char *tomoyo_get_local_path(struct dentry *dentry, char * const buffer,
 154                                    const int buflen)
 155 {
 156         struct super_block *sb = dentry->d_sb;
 157         char *pos = tomoyo_get_dentry_path(dentry, buffer, buflen);
 158
 159         if (IS_ERR(pos))
 160                 return pos;
 161         /* Convert from $PID to self if $PID is current thread. */
 162         if (sb->s_magic == PROC_SUPER_MAGIC && *pos == '/') {
 163                 char *ep;
 164                 const pid_t pid = (pid_t) simple_strtoul(pos + 1, &ep, 10);
 165                 struct pid_namespace *proc_pidns = proc_pid_ns(d_inode(dentry));
 166
 167                 if (*ep == '/' && pid && pid ==
 168                     task_tgid_nr_ns(current, proc_pidns)) {
 169                         pos = ep - 5;
 170                         if (pos < buffer)
 171                                 goto out;
 172                         memmove(pos, "/self", 5);
 173                 }
 174                 goto prepend_filesystem_name;
 175         }
 176         /* Use filesystem name for unnamed devices. */
 177         if (!MAJOR(sb->s_dev))
 178                 goto prepend_filesystem_name;
 179         {
 180                 struct inode *inode = d_backing_inode(sb->s_root);
 181
 182                 /*
 183                  * Use filesystem name if filesystem does not support rename()
 184                  * operation.
 185                  */
 186                 if (!inode->i_op->rename)
 187                         goto prepend_filesystem_name;
 188         }
 189         /* Prepend device name. */
 190         {
 191                 char name[64];
 192                 int name_len;
 193                 const dev_t dev = sb->s_dev;
 194
 195                 name[sizeof(name) - 1] = '\0';
 196                 snprintf(name, sizeof(name) - 1, "dev(%u,%u):", MAJOR(dev),
 197                          MINOR(dev));
 198                 name_len = strlen(name);
 199                 pos -= name_len;
 200                 if (pos < buffer)
 201                         goto out;
 202                 memmove(pos, name, name_len);
 203                 return pos;
 204         }
 205         /* Prepend filesystem name. */
 206 prepend_filesystem_name:
 207         {
 208                 const char *name = sb->s_type->name;
 209                 const int name_len = strlen(name);
 210
 211                 pos -= name_len + 1;
 212                 if (pos < buffer)
 213                         goto out;
 214                 memmove(pos, name, name_len);
 215                 pos[name_len] = ':';
 216         }
 217         return pos;
 218 out:
 219         return ERR_PTR(-ENOMEM);
 220 }
 221
 222 /**
 223  * tomoyo_realpath_from_path - Returns realpath(3) of the given pathname but ignores chroot'ed root.
 224  *
 225  * @path: Pointer to "struct path".
 226  *
 227  * Returns the realpath of the given @path on success, NULL otherwise.
 228  *
 229  * If dentry is a directory, trailing '/' is appended.
 230  * Characters out of 0x20 < c < 0x7F range are converted to
 231  * \ooo style octal string.
 232  * Character \ is converted to \\ string.
 233  *
 234  * These functions use kzalloc(), so the caller must call kfree()
 235  * if these functions didn't return NULL.
 236  */
 237 char *tomoyo_realpath_from_path(const struct path *path)
 238 {
 239         char *buf = NULL;
 240         char *name = NULL;
 241         unsigned int buf_len = PAGE_SIZE / 2;
 242         struct dentry *dentry = path->dentry;
 243         struct super_block *sb;
 244
 245         if (!dentry)
 246                 return NULL;
 247         sb = dentry->d_sb;
 248         while (1) {
 249                 char *pos;
 250                 struct inode *inode;
 251
 252                 buf_len <<= 1;
 253                 kfree(buf);
 254                 buf = kmalloc(buf_len, GFP_NOFS);
 255                 if (!buf)
 256                         break;
 257                 /* To make sure that pos is '\0' terminated. */
 258                 buf[buf_len - 1] = '\0';
 259                 /* For "pipe:[\$]" and "socket:[\$]". */
 260                 if (dentry->d_op && dentry->d_op->d_dname) {
 261                         pos = dentry->d_op->d_dname(dentry, buf, buf_len - 1);
 262                         goto encode;
 263                 }
 264                 inode = d_backing_inode(sb->s_root);
 265                 /*
 266                  * Get local name for filesystems without rename() operation
 267                  * or dentry without vfsmount.
 268                  */
 269                 if (!path->mnt ||
 270                     (!inode->i_op->rename &&
 271                      !(sb->s_type->fs_flags & FS_REQUIRES_DEV)))
 272                         pos = tomoyo_get_local_path(path->dentry, buf,
 273                                                     buf_len - 1);
 274                 /* Get absolute name for the rest. */
 275                 else {
 276                         pos = tomoyo_get_absolute_path(path, buf, buf_len - 1);
 277                         /*
 278                          * Fall back to local name if absolute name is not
 279                          * available.
 280                          */
 281                         if (pos == ERR_PTR(-EINVAL))
 282                                 pos = tomoyo_get_local_path(path->dentry, buf,
 283                                                             buf_len - 1);
 284                 }
 285 encode:
 286                 if (IS_ERR(pos))
 287                         continue;
 288                 name = tomoyo_encode(pos);
 289                 break;
 290         }
 291         kfree(buf);
 292         if (!name)
 293                 tomoyo_warn_oom(__func__);
 294         return name;
 295 }
 296
 297 /**
 298  * tomoyo_realpath_nofollow - Get realpath of a pathname.
 299  *
 300  * @pathname: The pathname to solve.
 301  *
 302  * Returns the realpath of @pathname on success, NULL otherwise.
 303  */
 304 char *tomoyo_realpath_nofollow(const char *pathname)
 305 {
 306         struct path path;
 307
 308         if (pathname && kern_path(pathname, 0, &path) == 0) {
 309                 char *buf = tomoyo_realpath_from_path(&path);
 310
 311                 path_put(&path);
 312                 return buf;
 313         }
 314         return NULL;
 315 }