security/keys/proc.c

   1 /* proc.c: proc files for key database enumeration
   2  *
   3  * Copyright (C) 2004 Red Hat, Inc. All Rights Reserved.
   4  * Written by David Howells (dhowells@redhat.com)
   5  *
   6  * This program is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU General Public License
   8  * as published by the Free Software Foundation; either version
   9  * 2 of the License, or (at your option) any later version.
  10  */
  11
  12 #include <linux/module.h>
  13 #include <linux/init.h>
  14 #include <linux/sched.h>
  15 #include <linux/fs.h>
  16 #include <linux/proc_fs.h>
  17 #include <linux/seq_file.h>
  18 #include <asm/errno.h>
  19 #include "internal.h"
  20
  21 #ifdef CONFIG_KEYS_DEBUG_PROC_KEYS
  22 static int proc_keys_open(struct inode *inode, struct file *file);
  23 static void *proc_keys_start(struct seq_file *p, loff_t *_pos);
  24 static void *proc_keys_next(struct seq_file *p, void *v, loff_t *_pos);
  25 static void proc_keys_stop(struct seq_file *p, void *v);
  26 static int proc_keys_show(struct seq_file *m, void *v);
  27
  28 static const struct seq_operations proc_keys_ops = {
  29         .start  = proc_keys_start,
  30         .next   = proc_keys_next,
  31         .stop   = proc_keys_stop,
  32         .show   = proc_keys_show,
  33 };
  34
  35 static const struct file_operations proc_keys_fops = {
  36         .open           = proc_keys_open,
  37         .read           = seq_read,
  38         .llseek         = seq_lseek,
  39         .release        = seq_release,
  40 };
  41 #endif
  42
  43 static int proc_key_users_open(struct inode *inode, struct file *file);
  44 static void *proc_key_users_start(struct seq_file *p, loff_t *_pos);
  45 static void *proc_key_users_next(struct seq_file *p, void *v, loff_t *_pos);
  46 static void proc_key_users_stop(struct seq_file *p, void *v);
  47 static int proc_key_users_show(struct seq_file *m, void *v);
  48
  49 static const struct seq_operations proc_key_users_ops = {
  50         .start  = proc_key_users_start,
  51         .next   = proc_key_users_next,
  52         .stop   = proc_key_users_stop,
  53         .show   = proc_key_users_show,
  54 };
  55
  56 static const struct file_operations proc_key_users_fops = {
  57         .open           = proc_key_users_open,
  58         .read           = seq_read,
  59         .llseek         = seq_lseek,
  60         .release        = seq_release,
  61 };
  62
  63 /*
  64  * declare the /proc files
  65  */
  66 static int __init key_proc_init(void)
  67 {
  68         struct proc_dir_entry *p;
  69
  70 #ifdef CONFIG_KEYS_DEBUG_PROC_KEYS
  71         p = proc_create("keys", 0, NULL, &proc_keys_fops);
  72         if (!p)
  73                 panic("Cannot create /proc/keys\n");
  74 #endif
  75
  76         p = proc_create("key-users", 0, NULL, &proc_key_users_fops);
  77         if (!p)
  78                 panic("Cannot create /proc/key-users\n");
  79
  80         return 0;
  81 }
  82
  83 __initcall(key_proc_init);
  84
  85 /*
  86  * implement "/proc/keys" to provides a list of the keys on the system
  87  */
  88 #ifdef CONFIG_KEYS_DEBUG_PROC_KEYS
  89
  90 static struct rb_node *key_serial_next(struct rb_node *n)
  91 {
  92         struct user_namespace *user_ns = current_user_ns();
  93
  94         n = rb_next(n);
  95         while (n) {
  96                 struct key *key = rb_entry(n, struct key, serial_node);
  97                 if (key->user->user_ns == user_ns)
  98                         break;
  99                 n = rb_next(n);
 100         }
 101         return n;
 102 }
 103
 104 static int proc_keys_open(struct inode *inode, struct file *file)
 105 {
 106         return seq_open(file, &proc_keys_ops);
 107 }
 108
 109 static struct key *find_ge_key(key_serial_t id)
 110 {
 111         struct user_namespace *user_ns = current_user_ns();
 112         struct rb_node *n = key_serial_tree.rb_node;
 113         struct key *minkey = NULL;
 114
 115         while (n) {
 116                 struct key *key = rb_entry(n, struct key, serial_node);
 117                 if (id < key->serial) {
 118                         if (!minkey || minkey->serial > key->serial)
 119                                 minkey = key;
 120                         n = n->rb_left;
 121                 } else if (id > key->serial) {
 122                         n = n->rb_right;
 123                 } else {
 124                         minkey = key;
 125                         break;
 126                 }
 127                 key = NULL;
 128         }
 129
 130         if (!minkey)
 131                 return NULL;
 132
 133         for (;;) {
 134                 if (minkey->user->user_ns == user_ns)
 135                         return minkey;
 136                 n = rb_next(&minkey->serial_node);
 137                 if (!n)
 138                         return NULL;
 139                 minkey = rb_entry(n, struct key, serial_node);
 140         }
 141 }
 142
 143 static void *proc_keys_start(struct seq_file *p, loff_t *_pos)
 144         __acquires(key_serial_lock)
 145 {
 146         key_serial_t pos = *_pos;
 147         struct key *key;
 148
 149         spin_lock(&key_serial_lock);
 150
 151         if (*_pos > INT_MAX)
 152                 return NULL;
 153         key = find_ge_key(pos);
 154         if (!key)
 155                 return NULL;
 156         *_pos = key->serial;
 157         return &key->serial_node;
 158 }
 159
 160 static inline key_serial_t key_node_serial(struct rb_node *n)
 161 {
 162         struct key *key = rb_entry(n, struct key, serial_node);
 163         return key->serial;
 164 }
 165
 166 static void *proc_keys_next(struct seq_file *p, void *v, loff_t *_pos)
 167 {
 168         struct rb_node *n;
 169
 170         n = key_serial_next(v);
 171         if (n)
 172                 *_pos = key_node_serial(n);
 173         return n;
 174 }
 175
 176 static void proc_keys_stop(struct seq_file *p, void *v)
 177         __releases(key_serial_lock)
 178 {
 179         spin_unlock(&key_serial_lock);
 180 }
 181
 182 static int proc_keys_show(struct seq_file *m, void *v)
 183 {
 184         const struct cred *cred = current_cred();
 185         struct rb_node *_p = v;
 186         struct key *key = rb_entry(_p, struct key, serial_node);
 187         struct timespec now;
 188         unsigned long timo;
 189         key_ref_t key_ref, skey_ref;
 190         char xbuf[12];
 191         int rc;
 192
 193         key_ref = make_key_ref(key, 0);
 194
 195         /* determine if the key is possessed by this process (a test we can
 196          * skip if the key does not indicate the possessor can view it
 197          */
 198         if (key->perm & KEY_POS_VIEW) {
 199                 skey_ref = search_my_process_keyrings(key->type, key,
 200                                                       lookup_user_key_possessed,
 201                                                       cred);
 202                 if (!IS_ERR(skey_ref)) {
 203                         key_ref_put(skey_ref);
 204                         key_ref = make_key_ref(key, 1);
 205                 }
 206         }
 207
 208         /* check whether the current task is allowed to view the key (assuming
 209          * non-possession)
 210          * - the caller holds a spinlock, and thus the RCU read lock, making our
 211          *   access to __current_cred() safe
 212          */
 213         rc = key_task_permission(key_ref, cred, KEY_VIEW);
 214         if (rc < 0)
 215                 return 0;
 216
 217         now = current_kernel_time();
 218
 219         rcu_read_lock();
 220
 221         /* come up with a suitable timeout value */
 222         if (key->expiry == 0) {
 223                 memcpy(xbuf, "perm", 5);
 224         } else if (now.tv_sec >= key->expiry) {
 225                 memcpy(xbuf, "expd", 5);
 226         } else {
 227                 timo = key->expiry - now.tv_sec;
 228
 229                 if (timo < 60)
 230                         sprintf(xbuf, "%lus", timo);
 231                 else if (timo < 60*60)
 232                         sprintf(xbuf, "%lum", timo / 60);
 233                 else if (timo < 60*60*24)
 234                         sprintf(xbuf, "%luh", timo / (60*60));
 235                 else if (timo < 60*60*24*7)
 236                         sprintf(xbuf, "%lud", timo / (60*60*24));
 237                 else
 238                         sprintf(xbuf, "%luw", timo / (60*60*24*7));
 239         }
 240
 241 #define showflag(KEY, LETTER, FLAG) \
 242         (test_bit(FLAG, &(KEY)->flags) ? LETTER : '-')
 243
 244         seq_printf(m, "%08x %c%c%c%c%c%c %5d %4s %08x %5d %5d %-9.9s ",
 245                    key->serial,
 246                    showflag(key, 'I', KEY_FLAG_INSTANTIATED),
 247                    showflag(key, 'R', KEY_FLAG_REVOKED),
 248                    showflag(key, 'D', KEY_FLAG_DEAD),
 249                    showflag(key, 'Q', KEY_FLAG_IN_QUOTA),
 250                    showflag(key, 'U', KEY_FLAG_USER_CONSTRUCT),
 251                    showflag(key, 'N', KEY_FLAG_NEGATIVE),
 252                    atomic_read(&key->usage),
 253                    xbuf,
 254                    key->perm,
 255                    key->uid,
 256                    key->gid,
 257                    key->type->name);
 258
 259 #undef showflag
 260
 261         if (key->type->describe)
 262                 key->type->describe(key, m);
 263         seq_putc(m, '\n');
 264
 265         rcu_read_unlock();
 266         return 0;
 267 }
 268
 269 #endif /* CONFIG_KEYS_DEBUG_PROC_KEYS */
 270
 271 static struct rb_node *__key_user_next(struct rb_node *n)
 272 {
 273         while (n) {
 274                 struct key_user *user = rb_entry(n, struct key_user, node);
 275                 if (user->user_ns == current_user_ns())
 276                         break;
 277                 n = rb_next(n);
 278         }
 279         return n;
 280 }
 281
 282 static struct rb_node *key_user_next(struct rb_node *n)
 283 {
 284         return __key_user_next(rb_next(n));
 285 }
 286
 287 static struct rb_node *key_user_first(struct rb_root *r)
 288 {
 289         struct rb_node *n = rb_first(r);
 290         return __key_user_next(n);
 291 }
 292
 293 /*
 294  * implement "/proc/key-users" to provides a list of the key users
 295  */
 296 static int proc_key_users_open(struct inode *inode, struct file *file)
 297 {
 298         return seq_open(file, &proc_key_users_ops);
 299 }
 300
 301 static void *proc_key_users_start(struct seq_file *p, loff_t *_pos)
 302         __acquires(key_user_lock)
 303 {
 304         struct rb_node *_p;
 305         loff_t pos = *_pos;
 306
 307         spin_lock(&key_user_lock);
 308
 309         _p = key_user_first(&key_user_tree);
 310         while (pos > 0 && _p) {
 311                 pos--;
 312                 _p = key_user_next(_p);
 313         }
 314
 315         return _p;
 316 }
 317
 318 static void *proc_key_users_next(struct seq_file *p, void *v, loff_t *_pos)
 319 {
 320         (*_pos)++;
 321         return key_user_next((struct rb_node *)v);
 322 }
 323
 324 static void proc_key_users_stop(struct seq_file *p, void *v)
 325         __releases(key_user_lock)
 326 {
 327         spin_unlock(&key_user_lock);
 328 }
 329
 330 static int proc_key_users_show(struct seq_file *m, void *v)
 331 {
 332         struct rb_node *_p = v;
 333         struct key_user *user = rb_entry(_p, struct key_user, node);
 334         unsigned maxkeys = (user->uid == 0) ?
 335                 key_quota_root_maxkeys : key_quota_maxkeys;
 336         unsigned maxbytes = (user->uid == 0) ?
 337                 key_quota_root_maxbytes : key_quota_maxbytes;
 338
 339         seq_printf(m, "%5u: %5d %d/%d %d/%d %d/%d\n",
 340                    user->uid,
 341                    atomic_read(&user->usage),
 342                    atomic_read(&user->nkeys),
 343                    atomic_read(&user->nikeys),
 344                    user->qnkeys,
 345                    maxkeys,
 346                    user->qnbytes,
 347                    maxbytes);
 348
 349         return 0;
 350 }