tests/sys/audit/file-create.c

   1 /*-
   2  * Copyright 2018 Aniket Pandey
   3  * All rights reserved.
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted provided that the following conditions
   7  * are met:
   8  * 1. Redistributions of source code must retain the above copyright
   9  *    notice, this list of conditions and the following disclaimer.
  10  * 2. Redistributions in binary form must reproduce the above copyright
  11  *    notice, this list of conditions and the following disclaimer in the
  12  *    documentation and/or other materials provided with the distribution.
  13  *
  14  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  15  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  16  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  17  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  18  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  19  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  20  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  21  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  22  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  23  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  24  * SUCH DAMAGE.
  25  *
  26  * $FreeBSD$
  27  */
  28
  29 #include <sys/types.h>
  30 #include <sys/stat.h>
  31
  32 #include <atf-c.h>
  33 #include <fcntl.h>
  34 #include <stdlib.h>
  35 #include <unistd.h>
  36
  37 #include "utils.h"
  38
  39 static struct pollfd fds[1];
  40 static mode_t mode = 0777;
  41 static dev_t dev =  0;
  42 static const char *auclass = "fc";
  43 static const char *path = "fileforaudit";
  44 static const char *successreg = "fileforaudit.*return,success";
  45 static const char *failurereg = "fileforaudit.*return,failure";
  46
  47
  48 ATF_TC_WITH_CLEANUP(mkdir_success);
  49 ATF_TC_HEAD(mkdir_success, tc)
  50 {
  51         atf_tc_set_md_var(tc, "descr", "Tests the audit of a successful "
  52                                         "mkdir(2) call");
  53 }
  54
  55 ATF_TC_BODY(mkdir_success, tc)
  56 {
  57         FILE *pipefd = setup(fds, auclass);
  58         ATF_REQUIRE_EQ(0, mkdir(path, mode));
  59         check_audit(fds, successreg, pipefd);
  60 }
  61
  62 ATF_TC_CLEANUP(mkdir_success, tc)
  63 {
  64         cleanup();
  65 }
  66
  67
  68 ATF_TC_WITH_CLEANUP(mkdir_failure);
  69 ATF_TC_HEAD(mkdir_failure, tc)
  70 {
  71         atf_tc_set_md_var(tc, "descr", "Tests the audit of an unsuccessful "
  72                                         "mkdir(2) call");
  73 }
  74
  75 ATF_TC_BODY(mkdir_failure, tc)
  76 {
  77         ATF_REQUIRE_EQ(0, mkdir(path, mode));
  78         FILE *pipefd = setup(fds, auclass);
  79         /* Failure reason: directory already exists */
  80         ATF_REQUIRE_EQ(-1, mkdir(path, mode));
  81         check_audit(fds, failurereg, pipefd);
  82 }
  83
  84 ATF_TC_CLEANUP(mkdir_failure, tc)
  85 {
  86         cleanup();
  87 }
  88
  89
  90 ATF_TC_WITH_CLEANUP(mkdirat_success);
  91 ATF_TC_HEAD(mkdirat_success, tc)
  92 {
  93         atf_tc_set_md_var(tc, "descr", "Tests the audit of a successful "
  94                                         "mkdirat(2) call");
  95 }
  96
  97 ATF_TC_BODY(mkdirat_success, tc)
  98 {
  99         FILE *pipefd = setup(fds, auclass);
 100         ATF_REQUIRE_EQ(0, mkdirat(AT_FDCWD, path, mode));
 101         check_audit(fds, successreg, pipefd);
 102 }
 103
 104 ATF_TC_CLEANUP(mkdirat_success, tc)
 105 {
 106         cleanup();
 107 }
 108
 109
 110 ATF_TC_WITH_CLEANUP(mkdirat_failure);
 111 ATF_TC_HEAD(mkdirat_failure, tc)
 112 {
 113         atf_tc_set_md_var(tc, "descr", "Tests the audit of an unsuccessful "
 114                                         "mkdirat(2) call");
 115 }
 116
 117 ATF_TC_BODY(mkdirat_failure, tc)
 118 {
 119         ATF_REQUIRE_EQ(0, mkdirat(AT_FDCWD, path, mode));
 120         FILE *pipefd = setup(fds, auclass);
 121         /* Failure reason: directory already exists */
 122         ATF_REQUIRE_EQ(-1, mkdirat(AT_FDCWD, path, mode));
 123         check_audit(fds, failurereg, pipefd);
 124 }
 125
 126 ATF_TC_CLEANUP(mkdirat_failure, tc)
 127 {
 128         cleanup();
 129 }
 130
 131
 132 ATF_TC_WITH_CLEANUP(mkfifo_success);
 133 ATF_TC_HEAD(mkfifo_success, tc)
 134 {
 135         atf_tc_set_md_var(tc, "descr", "Tests the audit of a successful "
 136                                         "mkfifo(2) call");
 137 }
 138
 139 ATF_TC_BODY(mkfifo_success, tc)
 140 {
 141         FILE *pipefd = setup(fds, auclass);
 142         ATF_REQUIRE_EQ(0, mkfifo(path, mode));
 143         check_audit(fds, successreg, pipefd);
 144 }
 145
 146 ATF_TC_CLEANUP(mkfifo_success, tc)
 147 {
 148         cleanup();
 149 }
 150
 151
 152 ATF_TC_WITH_CLEANUP(mkfifo_failure);
 153 ATF_TC_HEAD(mkfifo_failure, tc)
 154 {
 155         atf_tc_set_md_var(tc, "descr", "Tests the audit of an unsuccessful "
 156                                         "mkfifo(2) call");
 157 }
 158
 159 ATF_TC_BODY(mkfifo_failure, tc)
 160 {
 161         ATF_REQUIRE_EQ(0, mkfifo(path, mode));
 162         FILE *pipefd = setup(fds, auclass);
 163         /* Failure reason: FIFO already exists */
 164         ATF_REQUIRE_EQ(-1, mkfifo(path, mode));
 165         check_audit(fds, failurereg, pipefd);
 166 }
 167
 168 ATF_TC_CLEANUP(mkfifo_failure, tc)
 169 {
 170         cleanup();
 171 }
 172
 173
 174 ATF_TC_WITH_CLEANUP(mkfifoat_success);
 175 ATF_TC_HEAD(mkfifoat_success, tc)
 176 {
 177         atf_tc_set_md_var(tc, "descr", "Tests the audit of a successful "
 178                                         "mkfifoat(2) call");
 179 }
 180
 181 ATF_TC_BODY(mkfifoat_success, tc)
 182 {
 183         FILE *pipefd = setup(fds, auclass);
 184         ATF_REQUIRE_EQ(0, mkfifoat(AT_FDCWD, path, mode));
 185         check_audit(fds, successreg, pipefd);
 186 }
 187
 188 ATF_TC_CLEANUP(mkfifoat_success, tc)
 189 {
 190         cleanup();
 191 }
 192
 193
 194 ATF_TC_WITH_CLEANUP(mkfifoat_failure);
 195 ATF_TC_HEAD(mkfifoat_failure, tc)
 196 {
 197         atf_tc_set_md_var(tc, "descr", "Tests the audit of an unsuccessful "
 198                                         "mkfifoat(2) call");
 199 }
 200
 201 ATF_TC_BODY(mkfifoat_failure, tc)
 202 {
 203         ATF_REQUIRE_EQ(0, mkfifoat(AT_FDCWD, path, mode));
 204         FILE *pipefd = setup(fds, auclass);
 205         /* Failure reason: FIFO already exists */
 206         ATF_REQUIRE_EQ(-1, mkfifoat(AT_FDCWD, path, mode));
 207         check_audit(fds, failurereg, pipefd);
 208 }
 209
 210 ATF_TC_CLEANUP(mkfifoat_failure, tc)
 211 {
 212         cleanup();
 213 }
 214
 215
 216 ATF_TC_WITH_CLEANUP(mknod_success);
 217 ATF_TC_HEAD(mknod_success, tc)
 218 {
 219         atf_tc_set_md_var(tc, "descr", "Tests the audit of a successful "
 220                                         "mknod(2) call");
 221 }
 222
 223 ATF_TC_BODY(mknod_success, tc)
 224 {
 225         FILE *pipefd = setup(fds, auclass);
 226         ATF_REQUIRE_EQ(0, mknod(path, S_IFIFO | S_IRWXO, dev));
 227         check_audit(fds, successreg, pipefd);
 228 }
 229
 230 ATF_TC_CLEANUP(mknod_success, tc)
 231 {
 232         cleanup();
 233 }
 234
 235
 236 ATF_TC_WITH_CLEANUP(mknod_failure);
 237 ATF_TC_HEAD(mknod_failure, tc)
 238 {
 239         atf_tc_set_md_var(tc, "descr", "Tests the audit of an unsuccessful "
 240                                         "mknod(2) call");
 241 }
 242
 243 ATF_TC_BODY(mknod_failure, tc)
 244 {
 245         ATF_REQUIRE_EQ(0, mknod(path, S_IFIFO | S_IRWXO, dev));
 246         FILE *pipefd = setup(fds, auclass);
 247         /* Failure reason: FIFO node already exists */
 248         ATF_REQUIRE_EQ(-1, mknod(path, S_IFIFO | S_IRWXO, dev));
 249         check_audit(fds, failurereg, pipefd);
 250 }
 251
 252 ATF_TC_CLEANUP(mknod_failure, tc)
 253 {
 254         cleanup();
 255 }
 256
 257
 258 ATF_TC_WITH_CLEANUP(mknodat_success);
 259 ATF_TC_HEAD(mknodat_success, tc)
 260 {
 261         atf_tc_set_md_var(tc, "descr", "Tests the audit of a successful "
 262                                         "mknodat(2) call");
 263 }
 264
 265 ATF_TC_BODY(mknodat_success, tc)
 266 {
 267         FILE *pipefd = setup(fds, auclass);
 268         ATF_REQUIRE_EQ(0, mknodat(AT_FDCWD, path, S_IFIFO | S_IRWXO, dev));
 269         check_audit(fds, successreg, pipefd);
 270 }
 271
 272 ATF_TC_CLEANUP(mknodat_success, tc)
 273 {
 274         cleanup();
 275 }
 276
 277
 278 ATF_TC_WITH_CLEANUP(mknodat_failure);
 279 ATF_TC_HEAD(mknodat_failure, tc)
 280 {
 281         atf_tc_set_md_var(tc, "descr", "Tests the audit of an unsuccessful "
 282                                         "mknodat(2) call");
 283 }
 284
 285 ATF_TC_BODY(mknodat_failure, tc)
 286 {
 287         ATF_REQUIRE_EQ(0, mknodat(AT_FDCWD, path, S_IFIFO | S_IRWXO, dev));
 288         FILE *pipefd = setup(fds, auclass);
 289         /* Failure reason: FIFO node already exists */
 290         ATF_REQUIRE_EQ(-1, mknodat(AT_FDCWD, path, S_IFIFO | S_IRWXO, dev));
 291         check_audit(fds, failurereg, pipefd);
 292 }
 293
 294 ATF_TC_CLEANUP(mknodat_failure, tc)
 295 {
 296         cleanup();
 297 }
 298
 299
 300 ATF_TC_WITH_CLEANUP(rename_success);
 301 ATF_TC_HEAD(rename_success, tc)
 302 {
 303         atf_tc_set_md_var(tc, "descr", "Tests the audit of a successful "
 304                                         "rename(2) call");
 305 }
 306
 307 ATF_TC_BODY(rename_success, tc)
 308 {
 309         ATF_REQUIRE(open(path, O_CREAT, mode) != -1);
 310         FILE *pipefd = setup(fds, auclass);
 311         ATF_REQUIRE_EQ(0, rename(path, "renamed"));
 312         check_audit(fds, successreg, pipefd);
 313 }
 314
 315 ATF_TC_CLEANUP(rename_success, tc)
 316 {
 317         cleanup();
 318 }
 319
 320
 321 ATF_TC_WITH_CLEANUP(rename_failure);
 322 ATF_TC_HEAD(rename_failure, tc)
 323 {
 324         atf_tc_set_md_var(tc, "descr", "Tests the audit of an unsuccessful "
 325                                         "rename(2) call");
 326 }
 327
 328 ATF_TC_BODY(rename_failure, tc)
 329 {
 330         FILE *pipefd = setup(fds, auclass);
 331         /* Failure reason: file does not exist */
 332         ATF_REQUIRE_EQ(-1, rename(path, "renamed"));
 333         check_audit(fds, failurereg, pipefd);
 334 }
 335
 336 ATF_TC_CLEANUP(rename_failure, tc)
 337 {
 338         cleanup();
 339 }
 340
 341
 342 ATF_TC_WITH_CLEANUP(renameat_success);
 343 ATF_TC_HEAD(renameat_success, tc)
 344 {
 345         atf_tc_set_md_var(tc, "descr", "Tests the audit of a successful "
 346                                         "renameat(2) call");
 347 }
 348
 349 ATF_TC_BODY(renameat_success, tc)
 350 {
 351         ATF_REQUIRE(open(path, O_CREAT, mode) != -1);
 352         FILE *pipefd = setup(fds, auclass);
 353         ATF_REQUIRE_EQ(0, renameat(AT_FDCWD, path, AT_FDCWD, "renamed"));
 354         check_audit(fds, successreg, pipefd);
 355 }
 356
 357 ATF_TC_CLEANUP(renameat_success, tc)
 358 {
 359         cleanup();
 360 }
 361
 362
 363 ATF_TC_WITH_CLEANUP(renameat_failure);
 364 ATF_TC_HEAD(renameat_failure, tc)
 365 {
 366         atf_tc_set_md_var(tc, "descr", "Tests the audit of an unsuccessful "
 367                                         "renameat(2) call");
 368 }
 369
 370 ATF_TC_BODY(renameat_failure, tc)
 371 {
 372         FILE *pipefd = setup(fds, auclass);
 373         /* Failure reason: file does not exist */
 374         ATF_REQUIRE_EQ(-1, renameat(AT_FDCWD, path, AT_FDCWD, "renamed"));
 375         check_audit(fds, failurereg, pipefd);
 376 }
 377
 378 ATF_TC_CLEANUP(renameat_failure, tc)
 379 {
 380         cleanup();
 381 }
 382
 383
 384 ATF_TC_WITH_CLEANUP(link_success);
 385 ATF_TC_HEAD(link_success, tc)
 386 {
 387         atf_tc_set_md_var(tc, "descr", "Tests the audit of a successful "
 388                                         "link(2) call");
 389 }
 390
 391 ATF_TC_BODY(link_success, tc)
 392 {
 393         ATF_REQUIRE(open(path, O_CREAT, mode) != -1);
 394         FILE *pipefd = setup(fds, auclass);
 395         ATF_REQUIRE_EQ(0, link(path, "hardlink"));
 396         check_audit(fds, successreg, pipefd);
 397 }
 398
 399 ATF_TC_CLEANUP(link_success, tc)
 400 {
 401         cleanup();
 402 }
 403
 404
 405 ATF_TC_WITH_CLEANUP(link_failure);
 406 ATF_TC_HEAD(link_failure, tc)
 407 {
 408         atf_tc_set_md_var(tc, "descr", "Tests the audit of an unsuccessful "
 409                                         "link(2) call");
 410 }
 411
 412 ATF_TC_BODY(link_failure, tc)
 413 {
 414         FILE *pipefd = setup(fds, auclass);
 415         /* Failure reason: file does not exist */
 416         ATF_REQUIRE_EQ(-1, link(path, "hardlink"));
 417         check_audit(fds, failurereg, pipefd);
 418 }
 419
 420 ATF_TC_CLEANUP(link_failure, tc)
 421 {
 422         cleanup();
 423 }
 424
 425
 426 ATF_TC_WITH_CLEANUP(linkat_success);
 427 ATF_TC_HEAD(linkat_success, tc)
 428 {
 429         atf_tc_set_md_var(tc, "descr", "Tests the audit of a successful "
 430                                         "linkat(2) call");
 431 }
 432
 433 ATF_TC_BODY(linkat_success, tc)
 434 {
 435         ATF_REQUIRE(open(path, O_CREAT, mode) != -1);
 436         FILE *pipefd = setup(fds, auclass);
 437         ATF_REQUIRE_EQ(0, linkat(AT_FDCWD, path, AT_FDCWD, "hardlink", 0));
 438         check_audit(fds, successreg, pipefd);
 439 }
 440
 441 ATF_TC_CLEANUP(linkat_success, tc)
 442 {
 443         cleanup();
 444 }
 445
 446
 447 ATF_TC_WITH_CLEANUP(linkat_failure);
 448 ATF_TC_HEAD(linkat_failure, tc)
 449 {
 450         atf_tc_set_md_var(tc, "descr", "Tests the audit of an unsuccessful "
 451                                         "linkat(2) call");
 452 }
 453
 454 ATF_TC_BODY(linkat_failure, tc)
 455 {
 456         FILE *pipefd = setup(fds, auclass);
 457         /* Failure reason: file does not exist */
 458         ATF_REQUIRE_EQ(-1, linkat(AT_FDCWD, path, AT_FDCWD, "hardlink", 0));
 459         check_audit(fds, failurereg, pipefd);
 460 }
 461
 462 ATF_TC_CLEANUP(linkat_failure, tc)
 463 {
 464         cleanup();
 465 }
 466
 467
 468 ATF_TC_WITH_CLEANUP(symlink_success);
 469 ATF_TC_HEAD(symlink_success, tc)
 470 {
 471         atf_tc_set_md_var(tc, "descr", "Tests the audit of a successful "
 472                                         "symlink(2) call");
 473 }
 474
 475 ATF_TC_BODY(symlink_success, tc)
 476 {
 477         FILE *pipefd = setup(fds, auclass);
 478         ATF_REQUIRE_EQ(0, symlink(path, "symlink"));
 479         check_audit(fds, successreg, pipefd);
 480 }
 481
 482 ATF_TC_CLEANUP(symlink_success, tc)
 483 {
 484         cleanup();
 485 }
 486
 487
 488 ATF_TC_WITH_CLEANUP(symlink_failure);
 489 ATF_TC_HEAD(symlink_failure, tc)
 490 {
 491         atf_tc_set_md_var(tc, "descr", "Tests the audit of an unsuccessful "
 492                                         "symlink(2) call");
 493 }
 494
 495 ATF_TC_BODY(symlink_failure, tc)
 496 {
 497         ATF_REQUIRE_EQ(0, symlink(path, "symlink"));
 498         FILE *pipefd = setup(fds, auclass);
 499         /* Failure reason: symbolic link already exists */
 500         ATF_REQUIRE_EQ(-1, symlink(path, "symlink"));
 501         check_audit(fds, failurereg, pipefd);
 502 }
 503
 504 ATF_TC_CLEANUP(symlink_failure, tc)
 505 {
 506         cleanup();
 507 }
 508
 509
 510 ATF_TC_WITH_CLEANUP(symlinkat_success);
 511 ATF_TC_HEAD(symlinkat_success, tc)
 512 {
 513         atf_tc_set_md_var(tc, "descr", "Tests the audit of a successful "
 514                                         "symlinkat(2) call");
 515 }
 516
 517 ATF_TC_BODY(symlinkat_success, tc)
 518 {
 519         FILE *pipefd = setup(fds, auclass);
 520         ATF_REQUIRE_EQ(0, symlinkat(path, AT_FDCWD, "symlink"));
 521         check_audit(fds, successreg, pipefd);
 522 }
 523
 524 ATF_TC_CLEANUP(symlinkat_success, tc)
 525 {
 526         cleanup();
 527 }
 528
 529
 530 ATF_TC_WITH_CLEANUP(symlinkat_failure);
 531 ATF_TC_HEAD(symlinkat_failure, tc)
 532 {
 533         atf_tc_set_md_var(tc, "descr", "Tests the audit of an unsuccessful "
 534                                         "symlinkat(2) call");
 535 }
 536
 537 ATF_TC_BODY(symlinkat_failure, tc)
 538 {
 539         ATF_REQUIRE_EQ(0, symlinkat(path, AT_FDCWD, "symlink"));
 540         FILE *pipefd = setup(fds, auclass);
 541         /* Failure reason: symbolic link already exists */
 542         ATF_REQUIRE_EQ(-1, symlinkat(path, AT_FDCWD, "symlink"));
 543         check_audit(fds, failurereg, pipefd);
 544 }
 545
 546 ATF_TC_CLEANUP(symlinkat_failure, tc)
 547 {
 548         cleanup();
 549 }
 550
 551
 552 ATF_TP_ADD_TCS(tp)
 553 {
 554         ATF_TP_ADD_TC(tp, mkdir_success);
 555         ATF_TP_ADD_TC(tp, mkdir_failure);
 556         ATF_TP_ADD_TC(tp, mkdirat_success);
 557         ATF_TP_ADD_TC(tp, mkdirat_failure);
 558
 559         ATF_TP_ADD_TC(tp, mkfifo_success);
 560         ATF_TP_ADD_TC(tp, mkfifo_failure);
 561         ATF_TP_ADD_TC(tp, mkfifoat_success);
 562         ATF_TP_ADD_TC(tp, mkfifoat_failure);
 563
 564         ATF_TP_ADD_TC(tp, mknod_success);
 565         ATF_TP_ADD_TC(tp, mknod_failure);
 566         ATF_TP_ADD_TC(tp, mknodat_success);
 567         ATF_TP_ADD_TC(tp, mknodat_failure);
 568
 569         ATF_TP_ADD_TC(tp, rename_success);
 570         ATF_TP_ADD_TC(tp, rename_failure);
 571         ATF_TP_ADD_TC(tp, renameat_success);
 572         ATF_TP_ADD_TC(tp, renameat_failure);
 573
 574         ATF_TP_ADD_TC(tp, link_success);
 575         ATF_TP_ADD_TC(tp, link_failure);
 576         ATF_TP_ADD_TC(tp, linkat_success);
 577         ATF_TP_ADD_TC(tp, linkat_failure);
 578
 579         ATF_TP_ADD_TC(tp, symlink_success);
 580         ATF_TP_ADD_TC(tp, symlink_failure);
 581         ATF_TP_ADD_TC(tp, symlinkat_success);
 582         ATF_TP_ADD_TC(tp, symlinkat_failure);
 583
 584         return (atf_no_error());
 585 }