sys/dev/filemon/filemon_wrapper.c

   1 /*-
   2  * SPDX-License-Identifier: BSD-2-Clause-FreeBSD
   3  *
   4  * Copyright (c) 2011, David E. O'Brien.
   5  * Copyright (c) 2009-2011, Juniper Networks, Inc.
   6  * Copyright (c) 2015-2016, EMC Corp.
   7  * All rights reserved.
   8  *
   9  * Redistribution and use in source and binary forms, with or without
  10  * modification, are permitted provided that the following conditions
  11  * are met:
  12  * 1. Redistributions of source code must retain the above copyright
  13  *    notice, this list of conditions and the following disclaimer.
  14  * 2. Redistributions in binary form must reproduce the above copyright
  15  *    notice, this list of conditions and the following disclaimer in the
  16  *    documentation and/or other materials provided with the distribution.
  17  *
  18  * THIS SOFTWARE IS PROVIDED BY JUNIPER NETWORKS AND CONTRIBUTORS ``AS IS'' AND
  19  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  20  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  21  * ARE DISCLAIMED. IN NO EVENT SHALL JUNIPER NETWORKS OR CONTRIBUTORS BE LIABLE
  22  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  23  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  24  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  25  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  26  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  27  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  28  * SUCH DAMAGE.
  29  */
  30
  31 #include <sys/cdefs.h>
  32 __FBSDID("$FreeBSD$");
  33
  34 #include <sys/eventhandler.h>
  35 #include <sys/filedesc.h>
  36 #include <sys/imgact.h>
  37 #include <sys/priv.h>
  38 #include <sys/sx.h>
  39 #include <sys/sysent.h>
  40 #include <sys/vnode.h>
  41
  42 #include <machine/stdarg.h>
  43
  44 static void filemon_output_event(struct filemon *filemon, const char *fmt, ...)
  45     __printflike(2, 3);
  46
  47 static eventhandler_tag filemon_exec_tag;
  48 static eventhandler_tag filemon_exit_tag;
  49 static eventhandler_tag filemon_fork_tag;
  50
  51 static void
  52 filemon_output(struct filemon *filemon, char *msg, size_t len)
  53 {
  54         struct uio auio;
  55         struct iovec aiov;
  56         int error;
  57
  58         if (filemon->fp == NULL)
  59                 return;
  60
  61         aiov.iov_base = msg;
  62         aiov.iov_len = len;
  63         auio.uio_iov = &aiov;
  64         auio.uio_iovcnt = 1;
  65         auio.uio_resid = len;
  66         auio.uio_segflg = UIO_SYSSPACE;
  67         auio.uio_rw = UIO_WRITE;
  68         auio.uio_td = curthread;
  69         auio.uio_offset = (off_t) -1;
  70
  71         if (filemon->fp->f_type == DTYPE_VNODE)
  72                 bwillwrite();
  73
  74         error = fo_write(filemon->fp, &auio, filemon->cred, 0, curthread);
  75         if (error != 0 && filemon->error == 0)
  76                 filemon->error = error;
  77 }
  78
  79 static void
  80 filemon_output_event(struct filemon *filemon, const char *fmt, ...)
  81 {
  82         va_list ap;
  83         size_t len;
  84
  85         va_start(ap, fmt);
  86         len = vsnprintf(filemon->msgbufr, sizeof(filemon->msgbufr), fmt, ap);
  87         va_end(ap);
  88         /* The event is truncated but still worth logging. */
  89         if (len >= sizeof(filemon->msgbufr))
  90                 len = sizeof(filemon->msgbufr) - 1;
  91         filemon_output(filemon, filemon->msgbufr, len);
  92 }
  93
  94 static int
  95 filemon_wrapper_chdir(struct thread *td, struct chdir_args *uap)
  96 {
  97         int error, ret;
  98         struct filemon *filemon;
  99
 100         if ((ret = sys_chdir(td, uap)) == 0) {
 101                 if ((filemon = filemon_proc_get(curproc)) != NULL) {
 102                         if ((error = copyinstr(uap->path, filemon->fname1,
 103                             sizeof(filemon->fname1), NULL)) != 0) {
 104                                 filemon->error = error;
 105                                 goto copyfail;
 106                         }
 107
 108                         filemon_output_event(filemon, "C %d %s\n",
 109                             curproc->p_pid, filemon->fname1);
 110 copyfail:
 111                         filemon_drop(filemon);
 112                 }
 113         }
 114
 115         return (ret);
 116 }
 117
 118 static void
 119 filemon_event_process_exec(void *arg __unused, struct proc *p,
 120     struct image_params *imgp)
 121 {
 122         struct filemon *filemon;
 123
 124         if ((filemon = filemon_proc_get(p)) != NULL) {
 125                 filemon_output_event(filemon, "E %d %s\n",
 126                     p->p_pid,
 127                     imgp->execpath != NULL ? imgp->execpath : "<unknown>");
 128
 129                 /* If the credentials changed then cease tracing. */
 130                 if (imgp->newcred != NULL &&
 131                     imgp->credential_setid &&
 132                     priv_check_cred(filemon->cred,
 133                     PRIV_DEBUG_DIFFCRED, 0) != 0) {
 134                         /*
 135                          * It may have changed to NULL already, but
 136                          * will not be re-attached by anything else.
 137                          */
 138                         if (p->p_filemon != NULL) {
 139                                 KASSERT(p->p_filemon == filemon,
 140                                     ("%s: proc %p didn't have expected"
 141                                     " filemon %p", __func__, p, filemon));
 142                                 filemon_proc_drop(p);
 143                         }
 144                 }
 145
 146
 147                 filemon_drop(filemon);
 148         }
 149 }
 150
 151 static void
 152 _filemon_wrapper_openat(struct thread *td, const char *upath, int flags,
 153     int fd)
 154 {
 155         int error;
 156         struct file *fp;
 157         struct filemon *filemon;
 158         char *atpath, *freepath;
 159         cap_rights_t rights;
 160
 161         if ((filemon = filemon_proc_get(curproc)) != NULL) {
 162                 atpath = "";
 163                 freepath = NULL;
 164                 fp = NULL;
 165
 166                 if ((error = copyinstr(upath, filemon->fname1,
 167                     sizeof(filemon->fname1), NULL)) != 0) {
 168                         filemon->error = error;
 169                         goto copyfail;
 170                 }
 171
 172                 if (filemon->fname1[0] != '/' && fd != AT_FDCWD) {
 173                         /*
 174                          * rats - we cannot do too much about this.
 175                          * the trace should show a dir we read
 176                          * recently.. output an A record as a clue
 177                          * until we can do better.
 178                          * XXX: This may be able to come out with
 179                          * the namecache lookup now.
 180                          */
 181                         filemon_output_event(filemon, "A %d %s\n",
 182                             curproc->p_pid, filemon->fname1);
 183                         /*
 184                          * Try to resolve the path from the vnode using the
 185                          * namecache.  It may be inaccurate, but better
 186                          * than nothing.
 187                          */
 188                         if (getvnode(td, fd,
 189                             cap_rights_init(&rights, CAP_LOOKUP), &fp) == 0) {
 190                                 vn_fullpath(td, fp->f_vnode, &atpath,
 191                                     &freepath);
 192                         }
 193                 }
 194                 if (flags & O_RDWR) {
 195                         /*
 196                          * We'll get the W record below, but need
 197                          * to also output an R to distinguish from
 198                          * O_WRONLY.
 199                          */
 200                         filemon_output_event(filemon, "R %d %s%s%s\n",
 201                             curproc->p_pid, atpath,
 202                             atpath[0] != '\0' ? "/" : "", filemon->fname1);
 203                 }
 204
 205                 filemon_output_event(filemon, "%c %d %s%s%s\n",
 206                     (flags & O_ACCMODE) ? 'W':'R',
 207                     curproc->p_pid, atpath,
 208                     atpath[0] != '\0' ? "/" : "", filemon->fname1);
 209 copyfail:
 210                 filemon_drop(filemon);
 211                 if (fp != NULL)
 212                         fdrop(fp, td);
 213                 free(freepath, M_TEMP);
 214         }
 215 }
 216
 217 static int
 218 filemon_wrapper_open(struct thread *td, struct open_args *uap)
 219 {
 220         int ret;
 221
 222         if ((ret = sys_open(td, uap)) == 0)
 223                 _filemon_wrapper_openat(td, uap->path, uap->flags, AT_FDCWD);
 224
 225         return (ret);
 226 }
 227
 228 static int
 229 filemon_wrapper_openat(struct thread *td, struct openat_args *uap)
 230 {
 231         int ret;
 232
 233         if ((ret = sys_openat(td, uap)) == 0)
 234                 _filemon_wrapper_openat(td, uap->path, uap->flag, uap->fd);
 235
 236         return (ret);
 237 }
 238
 239 static int
 240 filemon_wrapper_rename(struct thread *td, struct rename_args *uap)
 241 {
 242         int error, ret;
 243         struct filemon *filemon;
 244
 245         if ((ret = sys_rename(td, uap)) == 0) {
 246                 if ((filemon = filemon_proc_get(curproc)) != NULL) {
 247                         if (((error = copyinstr(uap->from, filemon->fname1,
 248                              sizeof(filemon->fname1), NULL)) != 0) ||
 249                             ((error = copyinstr(uap->to, filemon->fname2,
 250                              sizeof(filemon->fname2), NULL)) != 0)) {
 251                                 filemon->error = error;
 252                                 goto copyfail;
 253                         }
 254
 255                         filemon_output_event(filemon, "M %d '%s' '%s'\n",
 256                             curproc->p_pid, filemon->fname1, filemon->fname2);
 257 copyfail:
 258                         filemon_drop(filemon);
 259                 }
 260         }
 261
 262         return (ret);
 263 }
 264
 265 static void
 266 _filemon_wrapper_link(struct thread *td, const char *upath1,
 267     const char *upath2)
 268 {
 269         struct filemon *filemon;
 270         int error;
 271
 272         if ((filemon = filemon_proc_get(curproc)) != NULL) {
 273                 if (((error = copyinstr(upath1, filemon->fname1,
 274                      sizeof(filemon->fname1), NULL)) != 0) ||
 275                     ((error = copyinstr(upath2, filemon->fname2,
 276                      sizeof(filemon->fname2), NULL)) != 0)) {
 277                         filemon->error = error;
 278                         goto copyfail;
 279                 }
 280
 281                 filemon_output_event(filemon, "L %d '%s' '%s'\n",
 282                     curproc->p_pid, filemon->fname1, filemon->fname2);
 283 copyfail:
 284                 filemon_drop(filemon);
 285         }
 286 }
 287
 288 static int
 289 filemon_wrapper_link(struct thread *td, struct link_args *uap)
 290 {
 291         int ret;
 292
 293         if ((ret = sys_link(td, uap)) == 0)
 294                 _filemon_wrapper_link(td, uap->path, uap->link);
 295
 296         return (ret);
 297 }
 298
 299 static int
 300 filemon_wrapper_symlink(struct thread *td, struct symlink_args *uap)
 301 {
 302         int ret;
 303
 304         if ((ret = sys_symlink(td, uap)) == 0)
 305                 _filemon_wrapper_link(td, uap->path, uap->link);
 306
 307         return (ret);
 308 }
 309
 310 static int
 311 filemon_wrapper_linkat(struct thread *td, struct linkat_args *uap)
 312 {
 313         int ret;
 314
 315         if ((ret = sys_linkat(td, uap)) == 0)
 316                 _filemon_wrapper_link(td, uap->path1, uap->path2);
 317
 318         return (ret);
 319 }
 320
 321 static void
 322 filemon_event_process_exit(void *arg __unused, struct proc *p)
 323 {
 324         struct filemon *filemon;
 325
 326         if ((filemon = filemon_proc_get(p)) != NULL) {
 327                 filemon_output_event(filemon, "X %d %d %d\n",
 328                     p->p_pid, p->p_xexit, p->p_xsig);
 329
 330                 /*
 331                  * filemon_untrack_processes() may have dropped this p_filemon
 332                  * already while in filemon_proc_get() before acquiring the
 333                  * filemon lock.
 334                  */
 335                 KASSERT(p->p_filemon == NULL || p->p_filemon == filemon,
 336                     ("%s: p %p was attached while exiting, expected "
 337                     "filemon %p or NULL", __func__, p, filemon));
 338                 if (p->p_filemon == filemon)
 339                         filemon_proc_drop(p);
 340
 341                 filemon_drop(filemon);
 342         }
 343 }
 344
 345 static int
 346 filemon_wrapper_unlink(struct thread *td, struct unlink_args *uap)
 347 {
 348         int error, ret;
 349         struct filemon *filemon;
 350
 351         if ((ret = sys_unlink(td, uap)) == 0) {
 352                 if ((filemon = filemon_proc_get(curproc)) != NULL) {
 353                         if ((error = copyinstr(uap->path, filemon->fname1,
 354                             sizeof(filemon->fname1), NULL)) != 0) {
 355                                 filemon->error = error;
 356                                 goto copyfail;
 357                         }
 358
 359                         filemon_output_event(filemon, "D %d %s\n",
 360                             curproc->p_pid, filemon->fname1);
 361 copyfail:
 362                         filemon_drop(filemon);
 363                 }
 364         }
 365
 366         return (ret);
 367 }
 368
 369 static void
 370 filemon_event_process_fork(void *arg __unused, struct proc *p1,
 371     struct proc *p2, int flags __unused)
 372 {
 373         struct filemon *filemon;
 374
 375         if ((filemon = filemon_proc_get(p1)) != NULL) {
 376                 filemon_output_event(filemon, "F %d %d\n",
 377                     p1->p_pid, p2->p_pid);
 378
 379                 /*
 380                  * filemon_untrack_processes() or
 381                  * filemon_ioctl(FILEMON_SET_PID) may have changed the parent's
 382                  * p_filemon while in filemon_proc_get() before acquiring the
 383                  * filemon lock.  Only inherit if the parent is still traced by
 384                  * this filemon.
 385                  */
 386                 if (p1->p_filemon == filemon) {
 387                         PROC_LOCK(p2);
 388                         /*
 389                          * It may have been attached to already by a new
 390                          * filemon.
 391                          */
 392                         if (p2->p_filemon == NULL) {
 393                                 p2->p_filemon = filemon_acquire(filemon);
 394                                 ++filemon->proccnt;
 395                         }
 396                         PROC_UNLOCK(p2);
 397                 }
 398
 399                 filemon_drop(filemon);
 400         }
 401 }
 402
 403 static void
 404 filemon_wrapper_install(void)
 405 {
 406
 407         sysent[SYS_chdir].sy_call = (sy_call_t *) filemon_wrapper_chdir;
 408         sysent[SYS_open].sy_call = (sy_call_t *) filemon_wrapper_open;
 409         sysent[SYS_openat].sy_call = (sy_call_t *) filemon_wrapper_openat;
 410         sysent[SYS_rename].sy_call = (sy_call_t *) filemon_wrapper_rename;
 411         sysent[SYS_unlink].sy_call = (sy_call_t *) filemon_wrapper_unlink;
 412         sysent[SYS_link].sy_call = (sy_call_t *) filemon_wrapper_link;
 413         sysent[SYS_symlink].sy_call = (sy_call_t *) filemon_wrapper_symlink;
 414         sysent[SYS_linkat].sy_call = (sy_call_t *) filemon_wrapper_linkat;
 415
 416 #if defined(COMPAT_FREEBSD32)
 417         freebsd32_sysent[FREEBSD32_SYS_chdir].sy_call = (sy_call_t *) filemon_wrapper_chdir;
 418         freebsd32_sysent[FREEBSD32_SYS_open].sy_call = (sy_call_t *) filemon_wrapper_open;
 419         freebsd32_sysent[FREEBSD32_SYS_openat].sy_call = (sy_call_t *) filemon_wrapper_openat;
 420         freebsd32_sysent[FREEBSD32_SYS_rename].sy_call = (sy_call_t *) filemon_wrapper_rename;
 421         freebsd32_sysent[FREEBSD32_SYS_unlink].sy_call = (sy_call_t *) filemon_wrapper_unlink;
 422         freebsd32_sysent[FREEBSD32_SYS_link].sy_call = (sy_call_t *) filemon_wrapper_link;
 423         freebsd32_sysent[FREEBSD32_SYS_symlink].sy_call = (sy_call_t *) filemon_wrapper_symlink;
 424         freebsd32_sysent[FREEBSD32_SYS_linkat].sy_call = (sy_call_t *) filemon_wrapper_linkat;
 425 #endif  /* COMPAT_FREEBSD32 */
 426
 427         filemon_exec_tag = EVENTHANDLER_REGISTER(process_exec,
 428             filemon_event_process_exec, NULL, EVENTHANDLER_PRI_LAST);
 429         filemon_exit_tag = EVENTHANDLER_REGISTER(process_exit,
 430             filemon_event_process_exit, NULL, EVENTHANDLER_PRI_LAST);
 431         filemon_fork_tag = EVENTHANDLER_REGISTER(process_fork,
 432             filemon_event_process_fork, NULL, EVENTHANDLER_PRI_LAST);
 433 }
 434
 435 static void
 436 filemon_wrapper_deinstall(void)
 437 {
 438
 439         sysent[SYS_chdir].sy_call = (sy_call_t *)sys_chdir;
 440         sysent[SYS_open].sy_call = (sy_call_t *)sys_open;
 441         sysent[SYS_openat].sy_call = (sy_call_t *)sys_openat;
 442         sysent[SYS_rename].sy_call = (sy_call_t *)sys_rename;
 443         sysent[SYS_unlink].sy_call = (sy_call_t *)sys_unlink;
 444         sysent[SYS_link].sy_call = (sy_call_t *)sys_link;
 445         sysent[SYS_symlink].sy_call = (sy_call_t *)sys_symlink;
 446         sysent[SYS_linkat].sy_call = (sy_call_t *)sys_linkat;
 447
 448 #if defined(COMPAT_FREEBSD32)
 449         freebsd32_sysent[FREEBSD32_SYS_chdir].sy_call = (sy_call_t *)sys_chdir;
 450         freebsd32_sysent[FREEBSD32_SYS_open].sy_call = (sy_call_t *)sys_open;
 451         freebsd32_sysent[FREEBSD32_SYS_openat].sy_call = (sy_call_t *)sys_openat;
 452         freebsd32_sysent[FREEBSD32_SYS_rename].sy_call = (sy_call_t *)sys_rename;
 453         freebsd32_sysent[FREEBSD32_SYS_unlink].sy_call = (sy_call_t *)sys_unlink;
 454         freebsd32_sysent[FREEBSD32_SYS_link].sy_call = (sy_call_t *)sys_link;
 455         freebsd32_sysent[FREEBSD32_SYS_symlink].sy_call = (sy_call_t *)sys_symlink;
 456         freebsd32_sysent[FREEBSD32_SYS_linkat].sy_call = (sy_call_t *)sys_linkat;
 457 #endif  /* COMPAT_FREEBSD32 */
 458
 459         EVENTHANDLER_DEREGISTER(process_exec, filemon_exec_tag);
 460         EVENTHANDLER_DEREGISTER(process_exit, filemon_exit_tag);
 461         EVENTHANDLER_DEREGISTER(process_fork, filemon_fork_tag);
 462 }