drivers/char/tty_audit.c

   1 /*
   2  * Creating audit events from TTY input.
   3  *
   4  * Copyright (C) 2007 Red Hat, Inc.  All rights reserved.  This copyrighted
   5  * material is made available to anyone wishing to use, modify, copy, or
   6  * redistribute it subject to the terms and conditions of the GNU General
   7  * Public License v.2.
   8  *
   9  * Authors: Miloslav Trmac <mitr@redhat.com>
  10  */
  11
  12 #include <linux/audit.h>
  13 #include <linux/file.h>
  14 #include <linux/tty.h>
  15
  16 struct tty_audit_buf {
  17         atomic_t count;
  18         struct mutex mutex;     /* Protects all data below */
  19         int major, minor;       /* The TTY which the data is from */
  20         unsigned icanon:1;
  21         size_t valid;
  22         unsigned char *data;    /* Allocated size N_TTY_BUF_SIZE */
  23 };
  24
  25 static struct tty_audit_buf *tty_audit_buf_alloc(int major, int minor,
  26                                                  int icanon)
  27 {
  28         struct tty_audit_buf *buf;
  29
  30         buf = kmalloc(sizeof(*buf), GFP_KERNEL);
  31         if (!buf)
  32                 goto err;
  33         if (PAGE_SIZE != N_TTY_BUF_SIZE)
  34                 buf->data = kmalloc(N_TTY_BUF_SIZE, GFP_KERNEL);
  35         else
  36                 buf->data = (unsigned char *)__get_free_page(GFP_KERNEL);
  37         if (!buf->data)
  38                 goto err_buf;
  39         atomic_set(&buf->count, 1);
  40         mutex_init(&buf->mutex);
  41         buf->major = major;
  42         buf->minor = minor;
  43         buf->icanon = icanon;
  44         buf->valid = 0;
  45         return buf;
  46
  47 err_buf:
  48         kfree(buf);
  49 err:
  50         return NULL;
  51 }
  52
  53 static void tty_audit_buf_free(struct tty_audit_buf *buf)
  54 {
  55         WARN_ON(buf->valid != 0);
  56         if (PAGE_SIZE != N_TTY_BUF_SIZE)
  57                 kfree(buf->data);
  58         else
  59                 free_page((unsigned long)buf->data);
  60         kfree(buf);
  61 }
  62
  63 static void tty_audit_buf_put(struct tty_audit_buf *buf)
  64 {
  65         if (atomic_dec_and_test(&buf->count))
  66                 tty_audit_buf_free(buf);
  67 }
  68
  69 /**
  70  *      tty_audit_buf_push      -       Push buffered data out
  71  *
  72  *      Generate an audit message from the contents of @buf, which is owned by
  73  *      @tsk with @loginuid.  @buf->mutex must be locked.
  74  */
  75 static void tty_audit_buf_push(struct task_struct *tsk, uid_t loginuid,
  76                                unsigned int sessionid,
  77                                struct tty_audit_buf *buf)
  78 {
  79         struct audit_buffer *ab;
  80
  81         if (buf->valid == 0)
  82                 return;
  83         if (audit_enabled == 0)
  84                 return;
  85         ab = audit_log_start(NULL, GFP_KERNEL, AUDIT_TTY);
  86         if (ab) {
  87                 char name[sizeof(tsk->comm)];
  88
  89                 audit_log_format(ab, "tty pid=%u uid=%u auid=%u ses=%u "
  90                                  "major=%d minor=%d comm=", tsk->pid, tsk->uid,
  91                                  loginuid, sessionid, buf->major, buf->minor);
  92                 get_task_comm(name, tsk);
  93                 audit_log_untrustedstring(ab, name);
  94                 audit_log_format(ab, " data=");
  95                 audit_log_n_untrustedstring(ab, buf->data, buf->valid);
  96                 audit_log_end(ab);
  97         }
  98         buf->valid = 0;
  99 }
 100
 101 /**
 102  *      tty_audit_buf_push_current      -       Push buffered data out
 103  *
 104  *      Generate an audit message from the contents of @buf, which is owned by
 105  *      the current task.  @buf->mutex must be locked.
 106  */
 107 static void tty_audit_buf_push_current(struct tty_audit_buf *buf)
 108 {
 109         uid_t auid = audit_get_loginuid(current);
 110         unsigned int sessionid = audit_get_sessionid(current);
 111         tty_audit_buf_push(current, auid, sessionid, buf);
 112 }
 113
 114 /**
 115  *      tty_audit_exit  -       Handle a task exit
 116  *
 117  *      Make sure all buffered data is written out and deallocate the buffer.
 118  *      Only needs to be called if current->signal->tty_audit_buf != %NULL.
 119  */
 120 void tty_audit_exit(void)
 121 {
 122         struct tty_audit_buf *buf;
 123
 124         spin_lock_irq(&current->sighand->siglock);
 125         buf = current->signal->tty_audit_buf;
 126         current->signal->tty_audit_buf = NULL;
 127         spin_unlock_irq(&current->sighand->siglock);
 128         if (!buf)
 129                 return;
 130
 131         mutex_lock(&buf->mutex);
 132         tty_audit_buf_push_current(buf);
 133         mutex_unlock(&buf->mutex);
 134
 135         tty_audit_buf_put(buf);
 136 }
 137
 138 /**
 139  *      tty_audit_fork  -       Copy TTY audit state for a new task
 140  *
 141  *      Set up TTY audit state in @sig from current.  @sig needs no locking.
 142  */
 143 void tty_audit_fork(struct signal_struct *sig)
 144 {
 145         spin_lock_irq(&current->sighand->siglock);
 146         sig->audit_tty = current->signal->audit_tty;
 147         spin_unlock_irq(&current->sighand->siglock);
 148         sig->tty_audit_buf = NULL;
 149 }
 150
 151 /**
 152  *      tty_audit_push_task     -       Flush task's pending audit data
 153  */
 154 void tty_audit_push_task(struct task_struct *tsk, uid_t loginuid, u32 sessionid)
 155 {
 156         struct tty_audit_buf *buf;
 157
 158         spin_lock_irq(&tsk->sighand->siglock);
 159         buf = tsk->signal->tty_audit_buf;
 160         if (buf)
 161                 atomic_inc(&buf->count);
 162         spin_unlock_irq(&tsk->sighand->siglock);
 163         if (!buf)
 164                 return;
 165
 166         mutex_lock(&buf->mutex);
 167         tty_audit_buf_push(tsk, loginuid, sessionid, buf);
 168         mutex_unlock(&buf->mutex);
 169
 170         tty_audit_buf_put(buf);
 171 }
 172
 173 /**
 174  *      tty_audit_buf_get       -       Get an audit buffer.
 175  *
 176  *      Get an audit buffer for @tty, allocate it if necessary.  Return %NULL
 177  *      if TTY auditing is disabled or out of memory.  Otherwise, return a new
 178  *      reference to the buffer.
 179  */
 180 static struct tty_audit_buf *tty_audit_buf_get(struct tty_struct *tty)
 181 {
 182         struct tty_audit_buf *buf, *buf2;
 183
 184         buf = NULL;
 185         buf2 = NULL;
 186         spin_lock_irq(&current->sighand->siglock);
 187         if (likely(!current->signal->audit_tty))
 188                 goto out;
 189         buf = current->signal->tty_audit_buf;
 190         if (buf) {
 191                 atomic_inc(&buf->count);
 192                 goto out;
 193         }
 194         spin_unlock_irq(&current->sighand->siglock);
 195
 196         buf2 = tty_audit_buf_alloc(tty->driver->major,
 197                                    tty->driver->minor_start + tty->index,
 198                                    tty->icanon);
 199         if (buf2 == NULL) {
 200                 audit_log_lost("out of memory in TTY auditing");
 201                 return NULL;
 202         }
 203
 204         spin_lock_irq(&current->sighand->siglock);
 205         if (!current->signal->audit_tty)
 206                 goto out;
 207         buf = current->signal->tty_audit_buf;
 208         if (!buf) {
 209                 current->signal->tty_audit_buf = buf2;
 210                 buf = buf2;
 211                 buf2 = NULL;
 212         }
 213         atomic_inc(&buf->count);
 214         /* Fall through */
 215  out:
 216         spin_unlock_irq(&current->sighand->siglock);
 217         if (buf2)
 218                 tty_audit_buf_free(buf2);
 219         return buf;
 220 }
 221
 222 /**
 223  *      tty_audit_add_data      -       Add data for TTY auditing.
 224  *
 225  *      Audit @data of @size from @tty, if necessary.
 226  */
 227 void tty_audit_add_data(struct tty_struct *tty, unsigned char *data,
 228                         size_t size)
 229 {
 230         struct tty_audit_buf *buf;
 231         int major, minor;
 232
 233         if (unlikely(size == 0))
 234                 return;
 235
 236         if (tty->driver->type == TTY_DRIVER_TYPE_PTY
 237             && tty->driver->subtype == PTY_TYPE_MASTER)
 238                 return;
 239
 240         buf = tty_audit_buf_get(tty);
 241         if (!buf)
 242                 return;
 243
 244         mutex_lock(&buf->mutex);
 245         major = tty->driver->major;
 246         minor = tty->driver->minor_start + tty->index;
 247         if (buf->major != major || buf->minor != minor
 248             || buf->icanon != tty->icanon) {
 249                 tty_audit_buf_push_current(buf);
 250                 buf->major = major;
 251                 buf->minor = minor;
 252                 buf->icanon = tty->icanon;
 253         }
 254         do {
 255                 size_t run;
 256
 257                 run = N_TTY_BUF_SIZE - buf->valid;
 258                 if (run > size)
 259                         run = size;
 260                 memcpy(buf->data + buf->valid, data, run);
 261                 buf->valid += run;
 262                 data += run;
 263                 size -= run;
 264                 if (buf->valid == N_TTY_BUF_SIZE)
 265                         tty_audit_buf_push_current(buf);
 266         } while (size != 0);
 267         mutex_unlock(&buf->mutex);
 268         tty_audit_buf_put(buf);
 269 }
 270
 271 /**
 272  *      tty_audit_push  -       Push buffered data out
 273  *
 274  *      Make sure no audit data is pending for @tty on the current process.
 275  */
 276 void tty_audit_push(struct tty_struct *tty)
 277 {
 278         struct tty_audit_buf *buf;
 279
 280         spin_lock_irq(&current->sighand->siglock);
 281         if (likely(!current->signal->audit_tty)) {
 282                 spin_unlock_irq(&current->sighand->siglock);
 283                 return;
 284         }
 285         buf = current->signal->tty_audit_buf;
 286         if (buf)
 287                 atomic_inc(&buf->count);
 288         spin_unlock_irq(&current->sighand->siglock);
 289
 290         if (buf) {
 291                 int major, minor;
 292
 293                 major = tty->driver->major;
 294                 minor = tty->driver->minor_start + tty->index;
 295                 mutex_lock(&buf->mutex);
 296                 if (buf->major == major && buf->minor == minor)
 297                         tty_audit_buf_push_current(buf);
 298                 mutex_unlock(&buf->mutex);
 299                 tty_audit_buf_put(buf);
 300         }
 301 }