contrib/openbsm/test/bsm/generate.c

   1 /*-
   2  * Copyright (c) 2006-2007 Robert N. M. Watson
   3  * Copyright (c) 2008 Apple Inc.
   4  * All rights reserved.
   5  *
   6  * Redistribution and use in source and binary forms, with or without
   7  * modification, are permitted provided that the following conditions
   8  * are met:
   9  * 1. Redistributions of source code must retain the above copyright
  10  *    notice, this list of conditions and the following disclaimer.
  11  * 2. Redistributions in binary form must reproduce the above copyright
  12  *    notice, this list of conditions and the following disclaimer in the
  13  *    documentation and/or other materials provided with the distribution.
  14  *
  15  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  16  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  17  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  18  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  19  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  20  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  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  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  25  * SUCH DAMAGE.
  26  */
  27
  28 /*
  29  * Generate a series of BSM token samples in the requested directory.
  30  */
  31
  32 #include <sys/types.h>
  33 #include <sys/socket.h>
  34 #include <sys/stat.h>
  35
  36 #include <netinet/in.h>
  37 #include <netinet/in_systm.h>
  38 #include <netinet/ip.h>
  39
  40 #include <arpa/inet.h>
  41
  42 #include <bsm/audit_kevents.h>
  43 #include <bsm/libbsm.h>
  44
  45 #include <err.h>
  46 #include <errno.h>
  47 #include <fcntl.h>
  48 #include <limits.h>
  49 #include <stdio.h>
  50 #include <stdlib.h>
  51 #include <string.h>
  52 #include <sysexits.h>
  53 #include <unistd.h>
  54
  55 static int      do_records, do_tokens;
  56
  57 static void
  58 usage(void)
  59 {
  60
  61         fprintf(stderr, "generate [-rt] path\n");
  62         exit(EX_USAGE);
  63 }
  64
  65 static int
  66 open_file(const char *directory, const char *name)
  67 {
  68         char pathname[PATH_MAX];
  69         int fd;
  70
  71         snprintf(pathname, PATH_MAX, "%s/%s", directory, name);
  72         (void)unlink(pathname);
  73         fd = open(pathname, O_WRONLY | O_CREAT | O_EXCL, 0600);
  74         if (fd < 0)
  75                 err(EX_CANTCREAT, "open: %s", name);
  76         return (fd);
  77 }
  78
  79 static void
  80 write_file(int fd, void *buffer, size_t buflen, const char *filename)
  81 {
  82         ssize_t len;
  83
  84         len = write(fd, buffer, buflen);
  85         if (len < 0)
  86                 err(EX_OSERR, "write_file: %s", filename);
  87         if (len < buflen)
  88                 err(EX_OSERR, "write_file: short write: %s", filename);
  89 }
  90
  91 /*
  92  * Write a single token to a file.
  93  */
  94 static void
  95 write_token(const char *directory, const char *filename, token_t *tok)
  96 {
  97         u_char buffer[MAX_AUDIT_RECORD_SIZE];
  98         size_t buflen;
  99         int fd;
 100
 101         buflen = MAX_AUDIT_RECORD_SIZE;
 102         if (au_close_token(tok, buffer, &buflen) < 0)
 103                 err(EX_UNAVAILABLE, "au_close_token");
 104         fd = open_file(directory, filename);
 105         write_file(fd, buffer, buflen, filename);
 106         close(fd);
 107 }
 108
 109 /*
 110  * Write a token to a file, wrapped in audit record header and trailer.
 111  */
 112 static void
 113 write_record(const char *directory, const char *filename, token_t *tok,
 114     short event)
 115 {
 116         u_char buffer[MAX_AUDIT_RECORD_SIZE];
 117         size_t buflen;
 118         int au, fd;
 119
 120         au = au_open();
 121         if (au < 0)
 122                 err(EX_UNAVAILABLE, "au_open");
 123         if (au_write(au, tok) < 0)
 124                 err(EX_UNAVAILABLE, "au_write");
 125         buflen = MAX_AUDIT_RECORD_SIZE;
 126         if (au_close_buffer(au, event, buffer, &buflen) < 0)
 127                 err(EX_UNAVAILABLE, "au_close_buffer");
 128         fd = open_file(directory, filename);
 129         write_file(fd, buffer, buflen, filename);
 130         close(fd);
 131 }
 132
 133 static struct timeval    file_token_timeval = { 0x12345, 0x67890} ;
 134
 135 static void
 136 generate_file_token(const char *directory, const char *token_filename)
 137 {
 138         token_t *file_token;
 139
 140         file_token = au_to_file("test", file_token_timeval);
 141         if (file_token == NULL)
 142                 err(EX_UNAVAILABLE, "au_to_file");
 143         write_token(directory, token_filename, file_token);
 144 }
 145
 146 static void
 147 generate_file_record(const char *directory, const char *record_filename)
 148 {
 149         token_t *file_token;
 150
 151         file_token = au_to_file("test", file_token_timeval);
 152         if (file_token == NULL)
 153                 err(EX_UNAVAILABLE, "au_to_file");
 154         write_record(directory, record_filename, file_token, AUE_NULL);
 155 }
 156
 157 /*
 158  * AUT_OHEADER
 159  */
 160
 161 static int               trailer_token_len = 0x12345678;
 162
 163 static void
 164 generate_trailer_token(const char *directory, const char *token_filename)
 165 {
 166         token_t *trailer_token;
 167
 168         trailer_token = au_to_trailer(trailer_token_len);
 169         if (trailer_token == NULL)
 170                 err(EX_UNAVAILABLE, "au_to_trailer");
 171         write_token(directory, token_filename, trailer_token);
 172 }
 173
 174 static int               header32_token_len = 0x12345678;
 175 static au_event_t        header32_e_type = AUE_OPEN;
 176 static au_emod_t         header32_e_mod = 0x4567;
 177 static struct timeval    header32_tm = { 0x12345, 0x67890 };
 178
 179 static void
 180 generate_header32_token(const char *directory, const char *token_filename)
 181 {
 182         token_t *header32_token;
 183
 184         header32_token = au_to_header32_tm(header32_token_len,
 185             header32_e_type, header32_e_mod, header32_tm);
 186         if (header32_token == NULL)
 187                 err(EX_UNAVAILABLE, "au_to_header32");
 188         write_token(directory, token_filename, header32_token);
 189 }
 190
 191 /*
 192  * AUT_HEADER32_EX
 193  */
 194
 195 static char              data_token_unit_print = AUP_STRING;
 196 static char              data_token_unit_type = AUR_CHAR;
 197 static char             *data_token_data = "SomeData";
 198 static char              data_token_unit_count = sizeof("SomeData") + 1;
 199
 200 static void
 201 generate_data_token(const char *directory, const char *token_filename)
 202 {
 203         token_t *data_token;
 204
 205         data_token = au_to_data(data_token_unit_print, data_token_unit_type,
 206             data_token_unit_count, data_token_data);
 207         if (data_token == NULL)
 208                 err(EX_UNAVAILABLE, "au_to_data");
 209         write_token(directory, token_filename, data_token);
 210 }
 211
 212 static void
 213 generate_data_record(const char *directory, const char *record_filename)
 214 {
 215         token_t *data_token;
 216
 217         data_token = au_to_data(data_token_unit_print, data_token_unit_type,
 218             data_token_unit_count, data_token_data);
 219         if (data_token == NULL)
 220                 err(EX_UNAVAILABLE, "au_to_data");
 221         write_record(directory, record_filename, data_token, AUE_NULL);
 222 }
 223
 224 static char              ipc_type = AT_IPC_MSG;
 225 static int               ipc_id = 0x12345678;
 226
 227 static void
 228 generate_ipc_token(const char *directory, const char *token_filename)
 229 {
 230         token_t *ipc_token;
 231
 232         ipc_token = au_to_ipc(ipc_type, ipc_id);
 233         if (ipc_token == NULL)
 234                 err(EX_UNAVAILABLE, "au_to_ipc");
 235         write_token(directory, token_filename, ipc_token);
 236 }
 237
 238 static void
 239 generate_ipc_record(const char *directory, const char *record_filename)
 240 {
 241         token_t *ipc_token;
 242
 243         ipc_token = au_to_ipc(ipc_type, ipc_id);
 244         if (ipc_token == NULL)
 245                 err(EX_UNAVAILABLE, "au_to_ipc");
 246         write_record(directory, record_filename, ipc_token, AUE_NULL);
 247 }
 248
 249 static char             *path_token_path = "/test/this/is/a/test";
 250
 251 static void
 252 generate_path_token(const char *directory, const char *token_filename)
 253 {
 254         token_t *path_token;
 255
 256         path_token = au_to_path(path_token_path);
 257         if (path_token == NULL)
 258                 err(EX_UNAVAILABLE, "au_to_path");
 259         write_token(directory, token_filename, path_token);
 260 }
 261
 262 static void
 263 generate_path_record(const char *directory, const char *record_filename)
 264 {
 265         token_t *path_token;
 266
 267         path_token = au_to_path(path_token_path);
 268         if (path_token == NULL)
 269                 err(EX_UNAVAILABLE, "au_to_path");
 270         write_record(directory, record_filename, path_token, AUE_NULL);
 271 }
 272
 273 static au_id_t           subject32_auid = 0x12345678;
 274 static uid_t             subject32_euid = 0x01234567;
 275 static gid_t             subject32_egid = 0x23456789;
 276 static uid_t             subject32_ruid = 0x98765432;
 277 static gid_t             subject32_rgid = 0x09876543;
 278 static pid_t             subject32_pid = 0x13243546;
 279 static au_asid_t         subject32_sid = 0x97867564;
 280 static au_tid_t          subject32_tid = { 0x16593746 };
 281 static au_tid_addr_t     subject32_tid_addr = { 0x16593746 };
 282
 283 static void
 284 generate_subject32_token(const char *directory, const char *token_filename)
 285 {
 286         token_t *subject32_token;
 287
 288         subject32_tid.machine = inet_addr("127.0.0.1");
 289
 290         subject32_token = au_to_subject32(subject32_auid, subject32_euid,
 291             subject32_egid, subject32_ruid, subject32_rgid, subject32_pid,
 292             subject32_sid, &subject32_tid);
 293         if (subject32_token == NULL)
 294                 err(EX_UNAVAILABLE, "au_to_subject32");
 295         write_token(directory, token_filename, subject32_token);
 296 }
 297
 298 static void
 299 generate_subject32_record(const char *directory, const char *record_filename)
 300 {
 301         token_t *subject32_token;
 302
 303         subject32_tid.machine = inet_addr("127.0.0.1");
 304
 305         subject32_token = au_to_subject32(subject32_auid, subject32_euid,
 306             subject32_egid, subject32_ruid, subject32_rgid, subject32_pid,
 307             subject32_sid, &subject32_tid);
 308         if (subject32_token == NULL)
 309                 err(EX_UNAVAILABLE, "au_to_subject32");
 310         write_record(directory, record_filename, subject32_token, AUE_NULL);
 311 }
 312
 313 static void
 314 generate_subject32ex_token(const char *directory, const char *token_filename,
 315     u_int32_t type)
 316 {
 317         token_t *subject32ex_token;
 318         char *buf;
 319
 320         buf = (char *)malloc(strlen(token_filename) + 6);
 321         if (type == AU_IPv6) {
 322                 inet_pton(AF_INET6, "fe80::1", subject32_tid_addr.at_addr);
 323                 subject32_tid_addr.at_type = AU_IPv6;
 324                 sprintf(buf, "%s%s", token_filename, "-IPv6");
 325         } else {
 326                 subject32_tid_addr.at_addr[0] = inet_addr("127.0.0.1");
 327                 subject32_tid_addr.at_type = AU_IPv4;
 328                 sprintf(buf, "%s%s", token_filename, "-IPv4");
 329         }
 330
 331         subject32ex_token = au_to_subject32_ex(subject32_auid, subject32_euid,
 332             subject32_egid, subject32_ruid, subject32_rgid, subject32_pid,
 333             subject32_sid, &subject32_tid_addr);
 334         if (subject32ex_token == NULL)
 335                 err(EX_UNAVAILABLE, "au_to_subject32_ex");
 336         write_token(directory, buf, subject32ex_token);
 337         free(buf);
 338 }
 339
 340 static void
 341 generate_subject32ex_record(const char *directory, const char *record_filename,
 342     u_int32_t type)
 343 {
 344         token_t *subject32ex_token;
 345         char *buf;
 346
 347         buf = (char *)malloc(strlen(record_filename) + 6);
 348         if (type == AU_IPv6) {
 349                 inet_pton(AF_INET6, "fe80::1", subject32_tid_addr.at_addr);
 350                 subject32_tid_addr.at_type = AU_IPv6;
 351                 sprintf(buf, "%s%s", record_filename, "-IPv6");
 352         } else {
 353                 subject32_tid_addr.at_addr[0] = inet_addr("127.0.0.1");
 354                 subject32_tid_addr.at_type = AU_IPv4;
 355                 sprintf(buf, "%s%s", record_filename, "-IPv4");
 356         }
 357
 358         subject32ex_token = au_to_subject32_ex(subject32_auid, subject32_euid,
 359             subject32_egid, subject32_ruid, subject32_rgid, subject32_pid,
 360             subject32_sid, &subject32_tid_addr);
 361         if (subject32ex_token == NULL)
 362                 err(EX_UNAVAILABLE, "au_to_subject32_ex");
 363         write_record(directory, record_filename, subject32ex_token, AUE_NULL);
 364         free(buf);
 365 }
 366
 367 static au_id_t           process32_auid = 0x12345678;
 368 static uid_t             process32_euid = 0x01234567;
 369 static gid_t             process32_egid = 0x23456789;
 370 static uid_t             process32_ruid = 0x98765432;
 371 static gid_t             process32_rgid = 0x09876543;
 372 static pid_t             process32_pid = 0x13243546;
 373 static au_asid_t         process32_sid = 0x97867564;
 374 static au_tid_t          process32_tid = { 0x16593746 };
 375 static au_tid_addr_t     process32_tid_addr = { 0x16593746 };
 376
 377 static void
 378 generate_process32_token(const char *directory, const char *token_filename)
 379 {
 380         token_t *process32_token;
 381
 382         process32_tid.machine = inet_addr("127.0.0.1");
 383
 384         process32_token = au_to_process32(process32_auid, process32_euid,
 385             process32_egid, process32_ruid, process32_rgid, process32_pid,
 386             process32_sid, &process32_tid);
 387         if (process32_token == NULL)
 388                 err(EX_UNAVAILABLE, "au_to_process32");
 389         write_token(directory, token_filename, process32_token);
 390 }
 391
 392 static void
 393 generate_process32_record(const char *directory, const char *record_filename)
 394 {
 395         token_t *process32_token;
 396
 397         process32_tid.machine = inet_addr("127.0.0.1");
 398
 399         process32_token = au_to_process32(process32_auid, process32_euid,
 400             process32_egid, process32_ruid, process32_rgid, process32_pid,
 401             process32_sid, &process32_tid);
 402         if (process32_token == NULL)
 403                 err(EX_UNAVAILABLE, "au_ti_process32");
 404         write_record(directory, record_filename, process32_token, AUE_NULL);
 405 }
 406
 407 static void
 408 generate_process32ex_token(const char *directory, const char *token_filename,
 409     u_int32_t type)
 410 {
 411         token_t *process32ex_token;
 412         char *buf;
 413
 414         buf = (char *)malloc(strlen(token_filename) + 6);
 415         if (type == AU_IPv6) {
 416                 inet_pton(AF_INET6, "fe80::1", process32_tid_addr.at_addr);
 417                 process32_tid_addr.at_type = AU_IPv6;
 418                 sprintf(buf, "%s%s", token_filename, "-IPv6");
 419         } else {
 420                 process32_tid_addr.at_addr[0] = inet_addr("127.0.0.1");
 421                 process32_tid_addr.at_type = AU_IPv4;
 422                 sprintf(buf, "%s%s", token_filename, "-IPv4");
 423         }
 424
 425         process32ex_token = au_to_process32_ex(process32_auid, process32_euid,
 426             process32_egid, process32_ruid, process32_rgid, process32_pid,
 427             process32_sid, &process32_tid_addr);
 428         if (process32ex_token == NULL)
 429                 err(EX_UNAVAILABLE, "au_to_process32_ex");
 430         write_token(directory, buf, process32ex_token);
 431         free(buf);
 432 }
 433
 434 static void
 435 generate_process32ex_record(const char *directory, const char *record_filename,
 436     u_int32_t type)
 437 {
 438         token_t *process32ex_token;
 439         char *buf;
 440
 441         buf = (char *)malloc(strlen(record_filename) + 6);
 442         if (type == AU_IPv6) {
 443                 inet_pton(AF_INET6, "fe80::1", process32_tid_addr.at_addr);
 444                 process32_tid_addr.at_type = AU_IPv6;
 445                 sprintf(buf, "%s%s", record_filename, "-IPv6");
 446         } else {
 447                 process32_tid_addr.at_addr[0] = inet_addr("127.0.0.1");
 448                 process32_tid_addr.at_type = AU_IPv4;
 449                 sprintf(buf, "%s%s", record_filename, "-IPv4");
 450         }
 451
 452         process32ex_token = au_to_process32_ex(process32_auid, process32_euid,
 453             process32_egid, process32_ruid, process32_rgid, process32_pid,
 454             process32_sid, &process32_tid_addr);
 455         if (process32ex_token == NULL)
 456                 err(EX_UNAVAILABLE, "au_to_process32_ex");
 457         write_record(directory, buf, process32ex_token, AUE_NULL);
 458         free(buf);
 459 }
 460
 461 static au_id_t           process64_auid = 0x12345678;
 462 static uid_t             process64_euid = 0x01234567;
 463 static gid_t             process64_egid = 0x23456789;
 464 static uid_t             process64_ruid = 0x98765432;
 465 static gid_t             process64_rgid = 0x09876543;
 466 static pid_t             process64_pid = 0x13243546;
 467 static au_asid_t         process64_sid = 0x97867564;
 468 static au_tid_t          process64_tid = { 0x16593746 };
 469 static au_tid_addr_t     process64_tid_addr = { 0x16593746 };
 470
 471 static void
 472 generate_process64_token(const char *directory, const char *token_filename)
 473 {
 474         token_t *process64_token;
 475
 476         process64_tid.machine = inet_addr("127.0.0.1");
 477
 478         process64_token = au_to_process64(process64_auid, process64_euid,
 479             process64_egid, process64_ruid, process64_rgid, process64_pid,
 480             process64_sid, &process64_tid);
 481         if (process64_token == NULL)
 482                 err(EX_UNAVAILABLE, "au_to_process64");
 483         write_token(directory, token_filename, process64_token);
 484 }
 485
 486 static void
 487 generate_process64_record(const char *directory, const char *record_filename)
 488 {
 489         token_t *process64_token;
 490
 491         process64_tid.machine = inet_addr("127.0.0.1");
 492
 493         process64_token = au_to_process64(process64_auid, process64_euid,
 494             process64_egid, process64_ruid, process64_rgid, process64_pid,
 495             process64_sid, &process64_tid);
 496         if (process64_token == NULL)
 497                 err(EX_UNAVAILABLE, "au_ti_process64");
 498         write_record(directory, record_filename, process64_token, AUE_NULL);
 499 }
 500
 501 static void
 502 generate_process64ex_token(const char *directory, const char *token_filename,
 503     u_int32_t type)
 504 {
 505         token_t *process64ex_token;
 506         char *buf;
 507
 508         buf = (char *)malloc(strlen(token_filename) + 6);
 509         if (type == AU_IPv6) {
 510                 inet_pton(AF_INET6, "fe80::1", process64_tid_addr.at_addr);
 511                 process64_tid_addr.at_type = AU_IPv6;
 512                 sprintf(buf, "%s%s", token_filename, "-IPv6");
 513         } else {
 514                 process64_tid_addr.at_addr[0] = inet_addr("127.0.0.1");
 515                 process64_tid_addr.at_type = AU_IPv4;
 516                 sprintf(buf, "%s%s", token_filename, "-IPv4");
 517         }
 518
 519         process64ex_token = au_to_process64_ex(process64_auid, process64_euid,
 520             process64_egid, process64_ruid, process64_rgid, process64_pid,
 521             process64_sid, &process64_tid_addr);
 522         if (process64ex_token == NULL)
 523                 err(EX_UNAVAILABLE, "au_to_process64_ex");
 524         write_token(directory, buf, process64ex_token);
 525         free(buf);
 526 }
 527
 528 static void
 529 generate_process64ex_record(const char *directory, const char *record_filename,
 530     u_int32_t type)
 531 {
 532         token_t *process64ex_token;
 533         char *buf;
 534
 535         buf = (char *)malloc(strlen(record_filename) + 6);
 536         if (type == AU_IPv6) {
 537                 inet_pton(AF_INET6, "fe80::1", process64_tid_addr.at_addr);
 538                 process64_tid_addr.at_type = AU_IPv6;
 539                 sprintf(buf, "%s%s", record_filename, "-IPv6");
 540         } else {
 541                 process64_tid_addr.at_addr[0] = inet_addr("127.0.0.1");
 542                 process64_tid_addr.at_type = AU_IPv4;
 543                 sprintf(buf, "%s%s", record_filename, "-IPv4");
 544         }
 545
 546         process64ex_token = au_to_process64_ex(process64_auid, process64_euid,
 547             process64_egid, process64_ruid, process64_rgid, process64_pid,
 548             process64_sid, &process64_tid_addr);
 549         if (process64ex_token == NULL)
 550                 err(EX_UNAVAILABLE, "au_to_process64_ex");
 551         write_record(directory, buf, process64ex_token, AUE_NULL);
 552         free(buf);
 553 }
 554
 555 static char              return32_status = EINVAL;
 556 static uint32_t          return32_ret = 0x12345678;
 557
 558 static void
 559 generate_return32_token(const char *directory, const char *token_filename)
 560 {
 561         token_t *return32_token;
 562
 563         return32_token = au_to_return32(au_errno_to_bsm(return32_status),
 564             return32_ret);
 565         if (return32_token == NULL)
 566                 err(EX_UNAVAILABLE, "au_to_return32");
 567         write_token(directory, token_filename, return32_token);
 568 }
 569
 570 static void
 571 generate_return32_record(const char *directory, const char *record_filename)
 572 {
 573         token_t *return32_token;
 574
 575         return32_token = au_to_return32(au_errno_to_bsm(return32_status),
 576             return32_ret);
 577         if (return32_token == NULL)
 578                 err(EX_UNAVAILABLE, "au_to_return32");
 579         write_record(directory, record_filename, return32_token, AUE_NULL);
 580 }
 581
 582 static char             *text_token_text = "This is a test.";
 583
 584 static void
 585 generate_text_token(const char *directory, const char *token_filename)
 586 {
 587         token_t *text_token;
 588
 589         text_token = au_to_text(text_token_text);
 590         if (text_token == NULL)
 591                 err(EX_UNAVAILABLE, "au_to_text");
 592         write_token(directory, token_filename, text_token);
 593 }
 594
 595 static void
 596 generate_text_record(const char *directory, const char *record_filename)
 597 {
 598         token_t *text_token;
 599
 600         text_token = au_to_text(text_token_text);
 601         if (text_token == NULL)
 602                 err(EX_UNAVAILABLE, "au_to_text");
 603         write_record(directory, record_filename, text_token, AUE_NULL);
 604 }
 605
 606 static char              opaque_token_data[] = {0xaa, 0xbb, 0xcc, 0xdd};
 607 static int               opaque_token_bytes = sizeof(opaque_token_data);
 608
 609 static void
 610 generate_opaque_token(const char *directory, const char *token_filename)
 611 {
 612         token_t *opaque_token;
 613
 614         opaque_token = au_to_opaque(opaque_token_data, opaque_token_bytes);
 615         if (opaque_token == NULL)
 616                 err(EX_UNAVAILABLE, "au_to_opaque");
 617         write_token(directory, token_filename, opaque_token);
 618 }
 619
 620 static void
 621 generate_opaque_record(const char *directory, const char *record_filename)
 622 {
 623         token_t *opaque_token;
 624
 625         opaque_token = au_to_opaque(opaque_token_data, opaque_token_bytes);
 626         if (opaque_token == NULL)
 627                 err(EX_UNAVAILABLE, "au_to_opaque");
 628         write_record(directory, record_filename, opaque_token, AUE_NULL);
 629 }
 630
 631 static struct in_addr    in_addr_token_addr;
 632
 633 static void
 634 generate_in_addr_token(const char *directory, const char *token_filename)
 635 {
 636         token_t *in_addr_token;
 637
 638         in_addr_token_addr.s_addr = inet_addr("192.168.100.15");
 639
 640         in_addr_token = au_to_in_addr(&in_addr_token_addr);
 641         if (in_addr_token == NULL)
 642                 err(EX_UNAVAILABLE, "au_to_in_addr");
 643         write_token(directory, token_filename, in_addr_token);
 644 }
 645
 646 static void
 647 generate_in_addr_record(const char *directory, const char *record_filename)
 648 {
 649         token_t *in_addr_token;
 650
 651         in_addr_token_addr.s_addr = inet_addr("192.168.100.15");
 652
 653         in_addr_token = au_to_in_addr(&in_addr_token_addr);
 654         if (in_addr_token == NULL)
 655                 err(EX_UNAVAILABLE, "au_to_in_addr");
 656         write_record(directory, record_filename, in_addr_token, AUE_NULL);
 657 }
 658
 659 static struct ip         ip_token_ip;
 660 static u_char            ip_token_ip_v = 4;
 661 static uint16_t          ip_token_ip_id = 0x5478;
 662 static u_char            ip_token_ip_ttl = 64;
 663 static u_char            ip_token_ip_p = IPPROTO_ICMP;
 664 static struct in_addr    ip_token_ip_src;
 665 static struct in_addr    ip_token_ip_dst;
 666
 667 static void
 668 generate_ip_token(const char *directory, const char *token_filename)
 669 {
 670         token_t *ip_token;
 671
 672         ip_token_ip_src.s_addr = inet_addr("192.168.100.155");
 673         ip_token_ip_dst.s_addr = inet_addr("192.168.110.48");
 674
 675         memset(&ip_token_ip, 0, sizeof(ip_token_ip));
 676         ip_token_ip.ip_v = ip_token_ip_v;
 677         ip_token_ip.ip_len = htons(sizeof(ip_token_ip));
 678         ip_token_ip.ip_id = htons(ip_token_ip_id);
 679         ip_token_ip.ip_ttl = ip_token_ip_ttl;
 680         ip_token_ip.ip_p = ip_token_ip_p;
 681         ip_token_ip.ip_src = ip_token_ip_src;
 682         ip_token_ip.ip_dst = ip_token_ip_dst;
 683
 684         ip_token = au_to_ip(&ip_token_ip);
 685         if (ip_token == NULL)
 686                 err(EX_UNAVAILABLE, "au_to_ip");
 687         write_token(directory, token_filename, ip_token);
 688 }
 689
 690 static void
 691 generate_ip_record(const char *directory, const char *record_filename)
 692 {
 693         token_t *ip_token;
 694
 695         ip_token_ip_src.s_addr = inet_addr("192.168.100.155");
 696         ip_token_ip_dst.s_addr = inet_addr("192.168.110.48");
 697
 698         memset(&ip_token_ip, 0, sizeof(ip_token_ip));
 699         ip_token_ip.ip_v = ip_token_ip_v;
 700         ip_token_ip.ip_len = htons(sizeof(ip_token_ip));
 701         ip_token_ip.ip_id = htons(ip_token_ip_id);
 702         ip_token_ip.ip_ttl = ip_token_ip_ttl;
 703         ip_token_ip.ip_p = ip_token_ip_p;
 704         ip_token_ip.ip_src = ip_token_ip_src;
 705         ip_token_ip.ip_dst = ip_token_ip_dst;
 706
 707         ip_token = au_to_ip(&ip_token_ip);
 708         if (ip_token == NULL)
 709                 err(EX_UNAVAILABLE, "au_to_ip");
 710         write_record(directory, record_filename, ip_token, AUE_NULL);
 711 }
 712
 713 static u_int16_t                 iport_token_iport;
 714
 715 static void
 716 generate_iport_token(const char *directory, const char *token_filename)
 717 {
 718         token_t *iport_token;
 719
 720         iport_token_iport = htons(80);
 721
 722         iport_token = au_to_iport(iport_token_iport);
 723         if (iport_token == NULL)
 724                 err(EX_UNAVAILABLE, "au_to_iport");
 725         write_token(directory, token_filename, iport_token);
 726 }
 727
 728 static void
 729 generate_iport_record(const char *directory, const char *record_filename)
 730 {
 731         token_t *iport_token;
 732
 733         iport_token_iport = htons(80);
 734
 735         iport_token = au_to_iport(iport_token_iport);
 736         if (iport_token == NULL)
 737                 err(EX_UNAVAILABLE, "au_to_iport");
 738         write_record(directory, record_filename, iport_token, AUE_NULL);
 739 }
 740
 741 static char      arg32_token_n = 3;
 742 static char     *arg32_token_text = "test_arg32_token";
 743 static uint32_t  arg32_token_v = 0xabcdef00;
 744
 745 static void
 746 generate_arg32_token(const char *directory, const char *token_filename)
 747 {
 748         token_t *arg32_token;
 749
 750         arg32_token = au_to_arg32(arg32_token_n, arg32_token_text,
 751             arg32_token_v);
 752         if (arg32_token == NULL)
 753                 err(EX_UNAVAILABLE, "au_to_arg32");
 754         write_token(directory, token_filename, arg32_token);
 755 }
 756
 757 static void
 758 generate_arg32_record(const char *directory, const char *record_filename)
 759 {
 760         token_t *arg32_token;
 761
 762         arg32_token = au_to_arg32(arg32_token_n, arg32_token_text,
 763             arg32_token_v);
 764         if (arg32_token == NULL)
 765                 err(EX_UNAVAILABLE, "au_to_arg32");
 766         write_record(directory, record_filename, arg32_token, AUE_NULL);
 767 }
 768
 769 static long      seq_audit_count = 0x12345678;
 770
 771 static void
 772 generate_seq_token(const char *directory, const char *token_filename)
 773 {
 774         token_t *seq_token;
 775
 776         seq_token = au_to_seq(seq_audit_count);
 777         if (seq_token == NULL)
 778                 err(EX_UNAVAILABLE, "au_to_seq");
 779         write_token(directory, token_filename, seq_token);
 780 }
 781
 782 static void
 783 generate_seq_record(const char *directory, const char *record_filename)
 784 {
 785         token_t *seq_token;
 786
 787         seq_token = au_to_seq(seq_audit_count);
 788         if (seq_token == NULL)
 789                 err(EX_UNAVAILABLE, "au_to_seq");
 790         write_record(directory, record_filename, seq_token, AUE_NULL);
 791 }
 792
 793 #if 0
 794 /*
 795  * AUT_ACL
 796  */
 797
 798 static void
 799 generate_attr_token(const char *directory, const char *token_filename)
 800 {
 801         token_t *attr_token;
 802
 803 }
 804
 805 static void
 806 generate_attr_record(const char *directory, const char *record_filename)
 807 {
 808         token_t *attr_token;
 809
 810 }
 811
 812 static void
 813 generate_ipc_perm_token(const char *directory, const char *token_filename)
 814 {
 815         token_t *ipc_perm_token;
 816
 817 }
 818
 819 static void
 820 generate_ipc_perm_record(const char *directory, const char *record_filename)
 821 {
 822         token_t *ipc_perm_token;
 823
 824 }
 825 #endif
 826
 827 #if 0
 828 /*
 829  * AUT_LABEL
 830  */
 831
 832 static void
 833 generate_groups_token(const char *directory, const char *token_filename)
 834 {
 835         token_t *groups_token;
 836
 837 }
 838
 839 static void
 840 generate_groups_record(const char *directory, const char *record_filename)
 841 {
 842         token_t *groups_token;
 843
 844 }
 845 #endif
 846
 847 /*
 848  * AUT_ILABEL
 849  */
 850
 851 /*
 852  * AUT_SLABEL
 853  */
 854
 855 /*
 856  * AUT_CLEAR
 857  */
 858
 859 /*
 860  * AUT_PRIV
 861  */
 862
 863 /*
 864  * AUT_UPRIV
 865  */
 866
 867 /*
 868  * AUT_LIAISON
 869  */
 870
 871 /*
 872  * AUT_NEWGROUPS
 873  */
 874
 875 /*
 876  * AUT_EXEC_ARGS
 877  */
 878
 879 /*
 880  * AUT_EXEC_ENV
 881  */
 882
 883 #if 0
 884 static void
 885 generate_attr32_token(const char *directory, const char *token_filename)
 886 {
 887         token_t *attr32_token;
 888
 889 }
 890
 891 static void
 892 generate_attr32_record(const char *directory, const char *record_filename)
 893 {
 894         token_t *attr32_token;
 895
 896 }
 897 #endif
 898
 899 static char     *zonename_sample = "testzone";
 900
 901 static void
 902 generate_zonename_token(const char *directory, const char *token_filename)
 903 {
 904         token_t *zonename_token;
 905
 906         zonename_token = au_to_zonename(zonename_sample);
 907         if (zonename_token == NULL)
 908                 err(EX_UNAVAILABLE, "au_to_zonename");
 909         write_token(directory, token_filename, zonename_token);
 910 }
 911
 912 static void
 913 generate_zonename_record(const char *directory, const char *record_filename)
 914 {
 915         token_t *zonename_token;
 916
 917         zonename_token = au_to_zonename(zonename_sample);
 918         if (zonename_token == NULL)
 919                 err(EX_UNAVAILABLE, "au_to_zonename");
 920         write_record(directory, record_filename, zonename_token, AUE_NULL);
 921 }
 922
 923 static u_short socketex_domain = PF_INET;
 924 static u_short socketex_type = SOCK_STREAM;
 925 static struct sockaddr_in socketex_laddr, socketex_raddr;
 926
 927 static void
 928 generate_socketex_token(const char *directory, const char *token_filename)
 929 {
 930         token_t *socketex_token;
 931
 932         bzero(&socketex_laddr, sizeof(socketex_laddr));
 933         socketex_laddr.sin_family = AF_INET;
 934         socketex_laddr.sin_len = sizeof(socketex_laddr);
 935         socketex_laddr.sin_addr.s_addr = htonl(INADDR_LOOPBACK);
 936
 937         bzero(&socketex_raddr, sizeof(socketex_raddr));
 938         socketex_raddr.sin_family = AF_INET;
 939         socketex_raddr.sin_len = sizeof(socketex_raddr);
 940         socketex_raddr.sin_addr.s_addr = htonl(INADDR_LOOPBACK);
 941
 942         socketex_token = au_to_socket_ex(au_domain_to_bsm(socketex_domain),
 943             au_socket_type_to_bsm(socketex_type),
 944             (struct sockaddr *)&socketex_laddr,
 945             (struct sockaddr *)&socketex_raddr);
 946         if (socketex_token == NULL)
 947                 err(EX_UNAVAILABLE, "au_to_socket_ex");
 948         write_token(directory, token_filename, socketex_token);
 949 }
 950
 951 static void
 952 generate_socketex_record(const char *directory, const char *record_filename)
 953 {
 954         token_t *socketex_token;
 955
 956         bzero(&socketex_laddr, sizeof(socketex_laddr));
 957         socketex_laddr.sin_family = AF_INET;
 958         socketex_laddr.sin_len = sizeof(socketex_laddr);
 959         socketex_laddr.sin_addr.s_addr = htonl(INADDR_LOOPBACK);
 960
 961         bzero(&socketex_raddr, sizeof(socketex_raddr));
 962         socketex_raddr.sin_family = AF_INET;
 963         socketex_raddr.sin_len = sizeof(socketex_raddr);
 964         socketex_raddr.sin_addr.s_addr = htonl(INADDR_LOOPBACK);
 965
 966         socketex_token = au_to_socket_ex(au_domain_to_bsm(socketex_domain),
 967             au_socket_type_to_bsm(socketex_type),
 968             (struct sockaddr *)&socketex_laddr,
 969             (struct sockaddr *)&socketex_raddr);
 970         if (socketex_token == NULL)
 971                 err(EX_UNAVAILABLE, "au_to_socket_ex");
 972         write_record(directory, record_filename, socketex_token, AUE_NULL);
 973 }
 974
 975 /*
 976  * Generate a series of error-number specific return tokens in records.
 977  */
 978 static void
 979 generate_error_record(const char *directory, const char *filename, int error)
 980 {
 981         char pathname[PATH_MAX];
 982         token_t *return32_token;
 983
 984         return32_token = au_to_return32(au_errno_to_bsm(error), -1);
 985         if (return32_token == NULL)
 986                 err(EX_UNAVAILABLE, "au_to_return32");
 987         (void)snprintf(pathname, PATH_MAX, "%s_record", filename);
 988         write_record(directory, pathname, return32_token, AUE_NULL);
 989 }
 990
 991 /*
 992  * Not all the error numbers, just a few present on all platforms for now.
 993  */
 994 const struct {
 995         int error_number;
 996         const char *error_name;
 997 } error_list[] = {
 998         { EPERM, "EPERM" },
 999         { ENOENT, "ENOENT" },
1000         { ESRCH, "ESRCH" },
1001         { EINTR, "EINTR" },
1002         { EIO, "EIO" },
1003         { ENXIO, "ENXIO" },
1004         { E2BIG, "E2BIG" },
1005         { ENOEXEC, "ENOEXEC" },
1006         { EBADF, "EBADF" },
1007         { ECHILD, "ECHILD" },
1008         { EDEADLK, "EDEADLK" },
1009         { ENOMEM, "ENOMEM" },
1010         { EACCES, "EACCES" },
1011         { EFAULT, "EFAULT" },
1012         { ENOTBLK, "ENOTBLK" },
1013         { EBUSY, "EBUSY" },
1014         { EEXIST, "EEXIST" },
1015         { EXDEV, "EXDEV" },
1016         { ENODEV, "ENODEV" },
1017         { ENOTDIR, "ENOTDIR" },
1018         { EISDIR, "EISDIR" },
1019         { EINVAL, "EINVAL" },
1020         { ENFILE, "ENFILE" },
1021         { EMFILE, "EMFILE" },
1022         { ENOTTY, "ENOTTY" },
1023         { ETXTBSY, "ETXTBSY" },
1024         { EFBIG, "EFBIG" },
1025         { ENOSPC, "ENOSPC" },
1026         { ESPIPE, "ESPIPE" },
1027         { EROFS, "EROFS" },
1028         { EMLINK, "EMLINK" },
1029         { EPIPE, "EPIPE" }
1030 };
1031 const int error_list_count = sizeof(error_list)/sizeof(error_list[0]);
1032
1033 static void
1034 do_error_records(const char *directory)
1035 {
1036         int i;
1037
1038         for (i = 0; i < error_list_count; i++)
1039                 generate_error_record(directory, error_list[i].error_name,
1040                     error_list[i].error_number);
1041 }
1042
1043 int
1044 main(int argc, char *argv[])
1045 {
1046         const char *directory;
1047         int ch;
1048
1049         while ((ch = getopt(argc, argv, "rt")) != -1) {
1050                 switch (ch) {
1051                 case 'r':
1052                         do_records++;
1053                         break;
1054
1055                 case 't':
1056                         do_tokens++;
1057                         break;
1058
1059                 default:
1060                         usage();
1061                 }
1062         }
1063
1064         argc -= optind;
1065         argv += optind;
1066
1067         if (argc != 1)
1068                 usage();
1069
1070         directory = argv[0];
1071
1072         if (mkdir(directory, 0755) < 0 && errno != EEXIST)
1073                 err(EX_OSERR, "mkdir: %s", directory);
1074
1075         if (do_tokens) {
1076                 generate_file_token(directory, "file_token");
1077                 generate_trailer_token(directory, "trailer_token");
1078                 generate_header32_token(directory, "header32_token");
1079                 generate_data_token(directory, "data_token");
1080                 generate_ipc_token(directory, "ipc_token");
1081                 generate_path_token(directory, "path_token");
1082                 generate_subject32_token(directory, "subject32_token");
1083                 generate_subject32ex_token(directory, "subject32ex_token",
1084                     AU_IPv4);
1085                 generate_subject32ex_token(directory, "subject32ex_token",
1086                     AU_IPv6);
1087                 generate_process32_token(directory, "process32_token");
1088                 generate_process32ex_token(directory, "process32ex_token",
1089                     AU_IPv4);
1090                 generate_process32ex_token(directory, "process32ex_token",
1091                     AU_IPv6);
1092                 generate_process64_token(directory, "process64_token");
1093                 generate_process64ex_token(directory, "process64ex_token",
1094                     AU_IPv4);
1095                 generate_process64ex_token(directory, "process64ex_token",
1096                     AU_IPv6);
1097                 generate_return32_token(directory, "return32_token");
1098                 generate_text_token(directory, "text_token");
1099                 generate_opaque_token(directory, "opaque_token");
1100                 generate_in_addr_token(directory, "in_addr_token");
1101                 generate_ip_token(directory, "ip_token");
1102                 generate_iport_token(directory, "iport_token");
1103                 generate_arg32_token(directory, "arg32_token");
1104                 generate_seq_token(directory, "seq_token");
1105 #if 0
1106                 generate_attr_token(directory,  "attr_token");
1107                 generate_ipc_perm_token(directory, "ipc_perm_token");
1108                 generate_groups_token(directory, "groups_token");
1109                 generate_attr32_token(directory, "attr32_token");
1110 #endif
1111                 generate_zonename_token(directory, "zonename_token");
1112                 generate_socketex_token(directory, "socketex_token");
1113         }
1114
1115         if (do_records) {
1116                 generate_file_record(directory, "file_record");
1117                 generate_data_record(directory, "data_record");
1118                 generate_ipc_record(directory, "ipc_record");
1119                 generate_path_record(directory, "path_record");
1120                 generate_subject32_record(directory, "subject32_record");
1121                 generate_subject32ex_record(directory, "subject32ex_record",
1122                     AU_IPv4);
1123                 generate_subject32ex_record(directory, "subject32ex_record",
1124                     AU_IPv6);
1125                 generate_process32_record(directory, "process32_record");
1126                 generate_process32ex_record(directory, "process32ex_record",
1127                     AU_IPv4);
1128                 generate_process32ex_record(directory, "process32ex_record",
1129                     AU_IPv6);
1130                 generate_process64_record(directory, "process64_record");
1131                 generate_process64ex_record(directory, "process64ex_record",
1132                     AU_IPv4);
1133                 generate_process64ex_record(directory, "process64ex_record",
1134                     AU_IPv6);
1135                 generate_return32_record(directory, "return32_record");
1136                 generate_text_record(directory, "text_record");
1137                 generate_opaque_record(directory, "opaque_record");
1138                 generate_in_addr_record(directory, "in_addr_record");
1139                 generate_ip_record(directory, "ip_record");
1140                 generate_iport_record(directory, "iport_record");
1141                 generate_arg32_record(directory, "arg32_record");
1142                 generate_seq_record(directory, "seq_record");
1143 #if 0
1144                 generate_attr_record(directory,  "attr_record");
1145                 generate_ipc_perm_record(directory, "ipc_perm_record");
1146                 generate_groups_record(directory, "groups_record");
1147                 generate_attr32_record(directory, "attr32_record");
1148 #endif
1149                 generate_zonename_record(directory, "zonename_record");
1150                 generate_socketex_record(directory, "socketex_record");
1151                 do_error_records(directory);
1152         }
1153
1154         return (0);
1155 }