1 /*
2 * CDDL HEADER START
3 *
4 * The contents of this file are subject to the terms of the
5 * Common Development and Distribution License (the "License").
6 * You may not use this file except in compliance with the License.
7 *
8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9 * or http://www.opensolaris.org/os/licensing.
10 * See the License for the specific language governing permissions
11 * and limitations under the License.
12 *
13 * When distributing Covered Code, include this CDDL HEADER in each
14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15 * If applicable, add the following below this CDDL HEADER, with the
16 * fields enclosed by brackets "[]" replaced with your own identifying
17 * information: Portions Copyright [yyyy] [name of copyright owner]
18 *
19 * CDDL HEADER END
20 */
21 /*
22 * Copyright 2010 Sun Microsystems, Inc. All rights reserved.
23 * Use is subject to license terms.
24 * Copyright 2012 Milan Jurik. All rights reserved.
25 */
26
27
28 /*
29 * Token processing for sysupd; each token function does one
30 * or more operations. All of them bump the buffer pointer
31 * to the next token; some of them extract one or more data
32 * from the token.
33 */
34
35 #define DEBUG 0
36 #if DEBUG
37 #define DPRINT(x) { (void) fprintf x; }
38 #else
39 #define DPRINT(x)
40 #endif
41
42 #include <locale.h>
43 #include <stdlib.h>
44 #include <stdio.h>
45 #include <string.h>
46 #include <sys/types.h>
47 #include <bsm/libbsm.h>
48 #include <sys/tsol/label.h>
49 #include "toktable.h" /* ../praudit */
50 #include "sysplugin.h"
51 #include "systoken.h"
52 #include <audit_plugin.h>
53
54 #if DEBUG
55 static FILE *dbfp; /* debug file */
56 #endif
57
58 static void anchor_path(char *);
59 static size_t collapse_path(char *, size_t);
60 static void get_bytes_to_string(parse_context_t *, size_t *, char **,
61 size_t);
62 static void skip_bytes(parse_context_t *);
63 static void skip_string(parse_context_t *);
64 static int xgeneric(parse_context_t *);
65
66 /*
67 * Process a token in a record to (1) extract data of interest if any
68 * and (2) point to the next token.
69 *
70 * returns 0 if ok. + or - values are of debug value:
71 *
72 * returns -1 if the parsing of the token failed.
73 *
74 * returns +<previous id> if the token is not found. This value
75 * is used to help determine where in the record the problem
76 * occurred. The common failure case is that the parsing of
77 * token M is incorrect and the buffer pointer ends up pointing
78 * to garbage. The positive error value of M *may* be the id of
79 * the incorrectly parsed token.
80 */
81
82 int
83 parse_token(parse_context_t *ctx)
84 {
85 char tokenid;
86 static char prev_tokenid = -1;
87 int rc;
88
89 #if DEBUG
90 static boolean_t first = 1;
91
92 if (first) {
93 dbfp = __auditd_debug_file_open();
94 first = 0;
95 }
96 #endif
97
98 adrm_char(&(ctx->adr), &tokenid, 1);
99
100 if ((tokenid > 0) && (tokentable[tokenid].func != NOFUNC)) {
101 rc = (*tokentable[tokenid].func)(ctx);
102 prev_tokenid = tokenid;
103 return (rc);
104 }
105 /* here if token id is not in table */
106 return (prev_tokenid);
107 }
108
109 /* There should not be any file tokens in the middle of a record */
110
111 /* ARGSUSED */
112 int
113 file_token(parse_context_t *ctx)
114 {
115
116 return (-1);
117 }
118
119 /* ARGSUSED */
120 int
121 file64_token(parse_context_t *ctx)
122 {
123 return (-1);
124 }
125
126 static void
127 common_header(parse_context_t *ctx)
128 {
129 adrm_u_int32(&(ctx->adr), &(ctx->out.sf_reclen), 1);
130 ctx->adr.adr_now += sizeof (char); /* version number */
131 adrm_u_short(&(ctx->adr), &(ctx->out.sf_eventid), 1);
132 ctx->adr.adr_now += sizeof (short); /* modifier */
133 }
134
135 /*
136 * 32bit header
137 */
138 int
139 header_token(parse_context_t *ctx)
140 {
141 common_header(ctx);
142 ctx->adr.adr_now += 2 * sizeof (int32_t); /* time */
143
144 return (0);
145 }
146
147
148 int
149 header32_ex_token(parse_context_t *ctx)
150 {
151 int32_t type;
152
153 common_header(ctx);
154
155 adrm_int32(&(ctx->adr), &type, 1); /* tid type */
156 ctx->adr.adr_now += type * sizeof (char); /* ip address */
157
158 ctx->adr.adr_now += 2 * sizeof (int32_t); /* time */
159
160 return (0);
161 }
162
163
164 int
165 header64_ex_token(parse_context_t *ctx)
166 {
167 int32_t type;
168
169 common_header(ctx);
170
171 adrm_int32(&(ctx->adr), &type, 1); /* tid type */
172 ctx->adr.adr_now += type * sizeof (char); /* ip address */
173
174 ctx->adr.adr_now += 2 * sizeof (int64_t); /* time */
175
176 return (0);
177 }
178
179
180 int
181 header64_token(parse_context_t *ctx)
182 {
183 common_header(ctx);
184
185 ctx->adr.adr_now += 2 * sizeof (int64_t); /* time */
186
187 return (0);
188 }
189
190
191 /*
192 * ======================================================
193 * The following token processing routines return
194 * 0: if parsed ok
195 * -1: can't parse and can't determine location of next token
196 * ======================================================
197 */
198
199 int
200 trailer_token(parse_context_t *ctx)
201 {
202 short magic_number;
203 uint32_t bytes;
204
205 adrm_u_short(&(ctx->adr), (ushort_t *)&magic_number, 1);
206 if (magic_number != AUT_TRAILER_MAGIC)
207 return (-1);
208
209 adrm_u_int32(&(ctx->adr), &bytes, 1);
210
211 return (0);
212 }
213
214
215 /*
216 * Format of arbitrary data token:
217 * arbitrary data token id &(ctx->adr) char
218 * how to print adr_char
219 * basic unit adr_char
220 * unit count adr_char, specifying number of units of
221 * data items depends on basic unit
222 *
223 */
224 int
225 arbitrary_data_token(parse_context_t *ctx)
226 {
227 char basic_unit, unit_count;
228
229 ctx->adr.adr_now += sizeof (char); /* how to print */
230
231 adrm_char(&(ctx->adr), &basic_unit, 1);
232 adrm_char(&(ctx->adr), &unit_count, 1);
233
234 switch (basic_unit) {
235 case AUR_CHAR: /* same as AUR_BYTE */
236 ctx->adr.adr_now += unit_count * sizeof (char);
237 break;
238 case AUR_SHORT:
239 ctx->adr.adr_now += unit_count * sizeof (short);
240 break;
241 case AUR_INT32: /* same as AUR_INT */
242 ctx->adr.adr_now += unit_count * sizeof (int32_t);
243 break;
244 case AUR_INT64:
245 ctx->adr.adr_now += unit_count * sizeof (int64_t);
246 break;
247 default:
248 return (-1);
249 }
250 return (0);
251 }
252
253
254 /*
255 * Format of opaque token:
256 * opaque token id adr_char
257 * size adr_short
258 * data adr_char, size times
259 *
260 */
261 int
262 opaque_token(parse_context_t *ctx)
263 {
264 skip_bytes(ctx);
265 return (0);
266 }
267
268
269 /*
270 * Format of return32 value token:
271 * return value token id adr_char
272 * error number adr_char
273 * return value adr_u_int32
274 *
275 */
276 int
277 return_value32_token(parse_context_t *ctx)
278 {
279 char errnum;
280
281 adrm_char(&(ctx->adr), &errnum, 1); /* pass / fail */
282 ctx->adr.adr_now += sizeof (int32_t); /* error code */
283
284 ctx->out.sf_pass = (errnum == 0) ? 1 : -1;
285
286 return (0);
287 }
288
289 /*
290 * Format of return64 value token:
291 * return value token id adr_char
292 * error number adr_char
293 * return value adr_u_int64
294 *
295 */
296 int
297 return_value64_token(parse_context_t *ctx)
298 {
299 char errnum;
300
301 adrm_char(&(ctx->adr), &errnum, 1); /* pass / fail */
302 ctx->adr.adr_now += sizeof (int64_t); /* error code */
303
304 ctx->out.sf_pass = (errnum == 0) ? 1 : -1;
305
306 return (0);
307 }
308
309
310 /*
311 * Format of sequence token:
312 * sequence token id adr_char
313 * audit_count int32_t
314 *
315 */
316 int
317 sequence_token(parse_context_t *ctx)
318 {
319 adrm_int32(&(ctx->adr), &(ctx->out.sf_sequence), 1);
320 return (0);
321 }
322
323
324 /*
325 * Format of text token:
326 * text token id adr_char
327 * text adr_string
328 */
329 int
330 text_token(parse_context_t *ctx)
331 {
332 ushort_t len;
333 size_t separator_sz = 0;
334 char *bp; /* pointer to output string */
335
336 adrm_u_short(&(ctx->adr), &len, 1);
337
338 if (ctx->out.sf_textlen > 0)
339 separator_sz = sizeof (AU_TEXT_NAME) - 1;
340
341 DPRINT((dbfp, "text_token: start length=%d, add length=%d+%d\n",
342 ctx->out.sf_textlen, (size_t)len, separator_sz));
343
344 ctx->out.sf_text = realloc(ctx->out.sf_text,
345 ctx->out.sf_textlen + (size_t)len + separator_sz);
346
347 if (ctx->out.sf_text == NULL)
348 return (-1);
349
350 bp = ctx->out.sf_text;
351
352 if (ctx->out.sf_textlen != 0) { /* concatenation? */
353 bp += ctx->out.sf_textlen;
354 bp += strlcpy(bp, AU_TEXT_NAME, separator_sz + 1);
355 ctx->out.sf_textlen += separator_sz;
356 DPRINT((dbfp, "text_token: l is %d\n%s\n", ctx->out.sf_textlen,
357 ctx->out.sf_text));
358 }
359 adrm_char(&(ctx->adr), bp, len);
360 len--; /* includes EOS */
361 *(bp + len) = '\0';
362
363 ctx->out.sf_textlen += len;
364 DPRINT((dbfp, "text_token: l=%d\n%s\n", ctx->out.sf_textlen,
365 ctx->out.sf_text));
366
367 return (0);
368 }
369
370 /*
371 * Format of tid token:
372 * ip token id adr_char
373 * terminal type adr_char
374 * terminal type = AU_IPADR:
375 * remote port: ushort
376 * local port: ushort
377 * IP type: int32 -- AU_IPv4 or AU_IPv6
378 * address: int32 if IPv4, else 4 * int32
379 */
380 int
381 tid_token(parse_context_t *ctx)
382 {
383 uchar_t type;
384 int32_t ip_length;
385
386 adrm_char(&(ctx->adr), (char *)&type, 1);
387
388 switch (type) {
389 default:
390 return (-1); /* other than IP type is not implemented */
391 case AU_IPADR:
392 ctx->adr.adr_now += 2 * sizeof (ushort_t);
393 adrm_int32(&(ctx->adr), &ip_length, 1);
394 ctx->adr.adr_now += ip_length;
395 break;
396 }
397 return (0);
398 }
399
400 /*
401 * Format of ip_addr token:
402 * ip token id adr_char
403 * address adr_int32
404 *
405 */
406 int
407 ip_addr_token(parse_context_t *ctx)
408 {
409 ctx->adr.adr_now += sizeof (int32_t);
410
411 return (0);
412 }
413
414 /*
415 * Format of ip_addr_ex token:
416 * ip token id adr_char
417 * ip type adr_int32
418 * ip address adr_u_char*type
419 *
420 */
421 int
422 ip_addr_ex_token(parse_context_t *ctx)
423 {
424 int32_t type;
425
426 adrm_int32(&(ctx->adr), &type, 1); /* ip type */
427 ctx->adr.adr_now += type * sizeof (uchar_t); /* ip address */
428
429 return (0);
430 }
431
432 /*
433 * Format of ip token:
434 * ip header token id adr_char
435 * version adr_char
436 * type of service adr_char
437 * length adr_short
438 * id adr_u_short
439 * offset adr_u_short
440 * ttl adr_char
441 * protocol adr_char
442 * checksum adr_u_short
443 * source address adr_int32
444 * destination address adr_int32
445 *
446 */
447 int
448 ip_token(parse_context_t *ctx)
449 {
450 ctx->adr.adr_now += (2 * sizeof (char)) + (3 * sizeof (short)) +
451 (2 * sizeof (char)) + sizeof (short) + (2 * sizeof (int32_t));
452 return (0);
453 }
454
455
456 /*
457 * Format of iport token:
458 * ip port address token id adr_char
459 * port address adr_short
460 *
461 */
462 int
463 iport_token(parse_context_t *ctx)
464 {
465 ctx->adr.adr_now += sizeof (short);
466
467 return (0);
468 }
469
470
471 /*
472 * Format of groups token:
473 * group token id adr_char
474 * group list adr_int32, 16 times
475 *
476 */
477 int
478 group_token(parse_context_t *ctx)
479 {
480 ctx->adr.adr_now += 16 * sizeof (int32_t);
481
482 return (0);
483 }
484
485 /*
486 * Format of newgroups token:
487 * group token id adr_char
488 * number of groups adr_short
489 * group list adr_int32, "number" times
490 *
491 */
492 int
493 newgroup_token(parse_context_t *ctx)
494 {
495 short int number;
496
497 adrm_short(&(ctx->adr), &number, 1);
498
499 ctx->adr.adr_now += number * sizeof (int32_t);
500
501 return (0);
502 }
503
504 /*
505 * Format of argument32 token:
506 * argument token id adr_char
507 * argument number adr_char
508 * argument value adr_int32
509 * argument description adr_string
510 *
511 */
512 int
513 argument32_token(parse_context_t *ctx)
514 {
515 ctx->adr.adr_now += sizeof (char) + sizeof (int32_t);
516 skip_bytes(ctx);
517
518 return (0);
519 }
520
521 /*
522 * Format of argument64 token:
523 * argument token id adr_char
524 * argument number adr_char
525 * argument value adr_int64
526 * argument description adr_string
527 *
528 */
529 int
530 argument64_token(parse_context_t *ctx)
531 {
532 ctx->adr.adr_now += sizeof (char) + sizeof (int64_t);
533 skip_bytes(ctx);
534
535 return (0);
536 }
537
538 /*
539 * Format of acl token:
540 * acl token id adr_char
541 * type adr_u_int32
542 * value adr_u_int32
543 * mode adr_u_int32
544 */
545 int
546 acl_token(parse_context_t *ctx)
547 {
548 ctx->adr.adr_now += 3 * sizeof (uint32_t);
549
550 return (0);
551 }
552
553 /*
554 * Format of ace token:
555 * ace token id adr_char
556 * id adr_u_int32
557 * access_mask adr_u_int32
558 * flags adr_u_short
559 * type adr_u_short
560 */
561 int
562 ace_token(parse_context_t *ctx)
563 {
564 ctx->adr.adr_now += 2 * sizeof (uint32_t) + 2 * sizeof (ushort_t);
565
566 return (0);
567 }
568
569 /*
570 * Format of attribute token: (old pre SunOS 5.7 format)
571 * attribute token id adr_char
572 * mode adr_int32 (printed in octal)
573 * uid adr_int32
574 * gid adr_int32
575 * file system id adr_int32
576 * node id adr_int32
577 * device adr_int32
578 *
579 */
580 int
581 attribute_token(parse_context_t *ctx)
582 {
583 ctx->adr.adr_now += 6 * sizeof (int32_t);
584
585 return (0);
586 }
587
588 /*
589 * Format of attribute32 token:
590 * attribute token id adr_char
591 * mode adr_int32 (printed in octal)
592 * uid adr_int32
593 * gid adr_int32
594 * file system id adr_int32
595 * node id adr_int64
596 * device adr_int32
597 *
598 */
599 int
600 attribute32_token(parse_context_t *ctx)
601 {
602 ctx->adr.adr_now += (5 * sizeof (int32_t)) + sizeof (int64_t);
603
604 return (0);
605 }
606
607 /*
608 * Format of attribute64 token:
609 * attribute token id adr_char
610 * mode adr_int32 (printed in octal)
611 * uid adr_int32
612 * gid adr_int32
613 * file system id adr_int32
614 * node id adr_int64
615 * device adr_int64
616 *
617 */
618 int
619 attribute64_token(parse_context_t *ctx)
620 {
621 ctx->adr.adr_now += (4 * sizeof (int32_t)) + (2 * sizeof (int64_t));
622
623 return (0);
624 }
625
626
627 /*
628 * Format of command token:
629 * attribute token id adr_char
630 * argc adr_short
631 * argv len adr_short variable amount of argv len
632 * argv text argv len and text
633 * .
634 * .
635 * .
636 * envp count adr_short variable amount of envp len
637 * envp len adr_short and text
638 * envp text envp len
639 * .
640 * .
641 * .
642 *
643 */
644 int
645 cmd_token(parse_context_t *ctx)
646 {
647 short cnt;
648 short i;
649
650 adrm_short(&(ctx->adr), &cnt, 1);
651
652 for (i = 0; i < cnt; i++)
653 skip_bytes(ctx);
654
655 adrm_short(&(ctx->adr), &cnt, 1);
656
657 for (i = 0; i < cnt; i++)
658 skip_bytes(ctx);
659
660 return (0);
661 }
662
663
664 /*
665 * Format of exit token:
666 * attribute token id adr_char
667 * return value adr_int32
668 * errno adr_int32
669 *
670 */
671 int
672 exit_token(parse_context_t *ctx)
673 {
674 int32_t retval;
675
676 adrm_int32(&(ctx->adr), &retval, 1);
677 ctx->adr.adr_now += sizeof (int32_t);
678
679 ctx->out.sf_pass = (retval == 0) ? 1 : -1;
680 return (0);
681 }
682
683 /*
684 * Format of exec_args token:
685 * attribute token id adr_char
686 * count value adr_int32
687 * strings null terminated strings
688 *
689 */
690 int
691 exec_args_token(parse_context_t *ctx)
692 {
693 int count, i;
694
695 adrm_int32(&(ctx->adr), (int32_t *)&count, 1);
696 for (i = 1; i <= count; i++) {
697 skip_string(ctx);
698 }
699
700 return (0);
701 }
702
703 /*
704 * Format of exec_env token:
705 * attribute token id adr_char
706 * count value adr_int32
707 * strings null terminated strings
708 *
709 */
710 int
711 exec_env_token(parse_context_t *ctx)
712 {
713 int count, i;
714
715 adrm_int32(&(ctx->adr), (int32_t *)&count, 1);
716 for (i = 1; i <= count; i++)
717 skip_string(ctx);
718
719 return (0);
720 }
721
722 /*
723 * Format of liaison token:
724 */
725 int
726 liaison_token(parse_context_t *ctx)
727 {
728 ctx->adr.adr_now += sizeof (int32_t);
729
730 return (0);
731 }
732
733
734 /*
735 * Format of path token:
736 * path adr_string
737 */
738 int
739 path_token(parse_context_t *ctx)
740 {
741 get_bytes_to_string(ctx, &(ctx->out.sf_pathlen), &(ctx->out.sf_path),
742 0);
743 if (ctx->out.sf_path == NULL)
744 return (-1);
745 /*
746 * anchor the path because collapse_path needs it
747 */
748 if (*(ctx->out.sf_path) != '/') {
749 anchor_path(ctx->out.sf_path);
750 ctx->out.sf_pathlen++;
751 }
752 ctx->out.sf_pathlen = collapse_path(ctx->out.sf_path,
753 ctx->out.sf_pathlen);
754
755 return (0);
756 }
757
758 /*
759 * path attr token / AUT_XATPATH
760 *
761 * Format of path attr token:
762 * token id adr_char
763 * string count adr_int32
764 * strings adr_string
765 *
766 * the sequence of strings is converted to a single string with
767 * a blank separator replacing the EOS for all but the last
768 * string.
769 */
770 int
771 path_attr_token(parse_context_t *ctx)
772 {
773 int count, i;
774 int last_len;
775 size_t offset;
776 char *p;
777
778 adrm_int32(&(ctx->adr), &count, 1);
779
780 offset = ctx->out.sf_atpathlen;
781 p = ctx->adr.adr_now;
782 for (i = 0; i <= count; i++) {
783 last_len = strlen(p);
784 ctx->out.sf_atpathlen += last_len + 1;
785 p += last_len + 1;
786 }
787 ctx->out.sf_atpath = realloc(ctx->out.sf_atpath, ctx->out.sf_atpathlen);
788 ctx->out.sf_atpath += offset;
789 p = ctx->out.sf_atpath; /* save for fix up, below */
790 (void) memcpy(ctx->out.sf_atpath, ctx->adr.adr_now,
791 ctx->out.sf_atpathlen - offset);
792 ctx->out.sf_atpathlen--;
793
794 /* fix up: replace each eos except the last with ' ' */
795
796 for (i = 0; i < count; i++) {
797 while (*p++ != '\0')
798 ;
799 *(p - 1) = ' ';
800 }
801 return (0);
802 }
803
804
805 /*
806 * Format of System V IPC permission token:
807 * System V IPC permission token id adr_char
808 * uid adr_int32
809 * gid adr_int32
810 * cuid adr_int32
811 * cgid adr_int32
812 * mode adr_int32
813 * seq adr_int32
814 * key adr_int32
815 */
816 int
817 s5_IPC_perm_token(parse_context_t *ctx)
818 {
819 ctx->adr.adr_now += (7 * sizeof (int32_t));
820 return (0);
821 }
822
823 static void
824 common_process(parse_context_t *ctx)
825 {
826 int32_t ruid, rgid, egid, pid;
827 uint32_t asid;
828
829 adrm_u_int32(&(ctx->adr), (uint32_t *)&(ctx->out.sf_pauid), 1);
830 adrm_u_int32(&(ctx->adr), (uint32_t *)&(ctx->out.sf_peuid), 1);
831 adrm_int32(&(ctx->adr), &egid, 1);
832 adrm_int32(&(ctx->adr), &ruid, 1);
833 adrm_int32(&(ctx->adr), &rgid, 1);
834 adrm_int32(&(ctx->adr), &pid, 1);
835 adrm_u_int32(&(ctx->adr), &asid, 1);
836 }
837
838 /*
839 * Format of process32 token:
840 * process token id adr_char
841 * auid adr_int32
842 * euid adr_int32
843 * egid adr_int32
844 * ruid adr_int32
845 * rgid adr_int32
846 * pid adr_int32
847 * sid adr_int32
848 * termid adr_int32*2
849 *
850 */
851 int
852 process32_token(parse_context_t *ctx)
853 {
854 int32_t port, machine;
855
856 common_process(ctx);
857
858 adrm_int32(&(ctx->adr), &port, 1);
859 adrm_int32(&(ctx->adr), &machine, 1);
860
861 return (0);
862 }
863
864 /*
865 * Format of process32_ex token:
866 * process token id adr_char
867 * auid adr_int32
868 * euid adr_int32
869 * egid adr_int32
870 * ruid adr_int32
871 * rgid adr_int32
872 * pid adr_int32
873 * sid adr_int32
874 * termid
875 * port adr_int32
876 * type adr_int32
877 * ip address adr_u_char*type
878 *
879 */
880 int
881 process32_ex_token(parse_context_t *ctx)
882 {
883 int32_t port, type;
884 uchar_t addr[16];
885
886 common_process(ctx);
887
888 adrm_int32(&(ctx->adr), &port, 1);
889 adrm_int32(&(ctx->adr), &type, 1);
890 adrm_u_char(&(ctx->adr), addr, type);
891
892 return (0);
893 }
894
895 /*
896 * Format of process64 token:
897 * process token id adr_char
898 * auid adr_int32
899 * euid adr_int32
900 * egid adr_int32
901 * ruid adr_int32
902 * rgid adr_int32
903 * pid adr_int32
904 * sid adr_int32
905 * termid adr_int64+adr_int32
906 *
907 */
908 int
909 process64_token(parse_context_t *ctx)
910 {
911 int64_t port;
912 int32_t machine;
913
914 common_process(ctx);
915
916 adrm_int64(&(ctx->adr), &port, 1);
917 adrm_int32(&(ctx->adr), &machine, 1);
918
919 return (0);
920 }
921
922 /*
923 * Format of process64_ex token:
924 * process token id adr_char
925 * auid adr_int32
926 * euid adr_int32
927 * egid adr_int32
928 * ruid adr_int32
929 * rgid adr_int32
930 * pid adr_int32
931 * sid adr_int32
932 * termid
933 * port adr_int64
934 * type adr_int32
935 * ip address adr_u_char*type
936 *
937 */
938 int
939 process64_ex_token(parse_context_t *ctx)
940 {
941 int64_t port;
942 int32_t type;
943 uchar_t addr[16];
944
945 common_process(ctx);
946
947 adrm_int64(&(ctx->adr), &port, 1);
948 adrm_int32(&(ctx->adr), &type, 1);
949 adrm_u_char(&(ctx->adr), addr, type);
950
951 return (0);
952 }
953
954 /*
955 * Format of System V IPC token:
956 * System V IPC token id adr_char
957 * System V IPC type adr_char
958 * object id adr_int32
959 *
960 */
961 int
962 s5_IPC_token(parse_context_t *ctx)
963 {
964 ctx->adr.adr_now += sizeof (char);
965 ctx->adr.adr_now += sizeof (int32_t);
966
967 return (0);
968 }
969
970
971 /*
972 * Format of socket token:
973 * socket_type adrm_short
974 * remote_port adrm_short
975 * remote_inaddr adrm_int32
976 *
977 */
978 int
979 socket_token(parse_context_t *ctx)
980 {
981 ctx->adr.adr_now += (2 * sizeof (short)) + sizeof (int32_t);
982
983 return (0);
984 }
985
986
987 /*
988 * Format of socket_ex token:
989 * socket_domain adrm_short
990 * socket_type adrm_short
991 * address_type adrm_short
992 * local_port adrm_short
993 * local_inaddr adrm_u_char*address_type
994 * remote_port adrm_short
995 * remote_inaddr adrm_u_char*address_type
996 *
997 */
998 int
999 socket_ex_token(parse_context_t *ctx)
1000 {
1001 short ip_size;
1002
1003 ctx->adr.adr_now += (2 * sizeof (short));
1004 adrm_short(&(ctx->adr), &ip_size, 1);
1005
1006 ctx->adr.adr_now += sizeof (short) + (ip_size * sizeof (char)) +
1007 sizeof (short) + (ip_size * sizeof (char));
1008 return (0);
1009 }
1010
1011
1012 static void
1013 common_subject(parse_context_t *ctx)
1014 {
1015 int32_t ruid, rgid, pid;
1016
1017 adrm_u_int32(&(ctx->adr), (uint32_t *)&(ctx->out.sf_auid), 1);
1018 adrm_u_int32(&(ctx->adr), (uint32_t *)&(ctx->out.sf_euid), 1);
1019 adrm_u_int32(&(ctx->adr), (uint32_t *)&(ctx->out.sf_egid), 1);
1020 adrm_int32(&(ctx->adr), &ruid, 1);
1021 adrm_int32(&(ctx->adr), &rgid, 1);
1022 adrm_int32(&(ctx->adr), &pid, 1);
1023 adrm_u_int32(&(ctx->adr), (uint32_t *)&(ctx->out.sf_asid), 1);
1024 }
1025
1026 /*
1027 * Format of subject32 token:
1028 * subject token id adr_char
1029 * auid adr_int32
1030 * euid adr_int32
1031 * egid adr_int32
1032 * ruid adr_int32
1033 * rgid adr_int32
1034 * pid adr_int32
1035 * sid adr_int32
1036 * termid adr_int32*2
1037 *
1038 */
1039 int
1040 subject32_token(parse_context_t *ctx)
1041 {
1042 int32_t port; /* not used in output */
1043
1044 common_subject(ctx);
1045
1046 adrm_int32(&(ctx->adr), &port, 1);
1047 ctx->out.sf_tid.at_type = AU_IPv4;
1048 adrm_u_char(&(ctx->adr), (uchar_t *)&(ctx->out.sf_tid.at_addr[0]), 4);
1049
1050 return (0);
1051 }
1052
1053 /*
1054 * Format of subject32_ex token:
1055 * subject token id adr_char
1056 * auid adr_int32
1057 * euid adr_int32
1058 * egid adr_int32
1059 * ruid adr_int32
1060 * rgid adr_int32
1061 * pid adr_int32
1062 * sid adr_int32
1063 * termid
1064 * port adr_int32
1065 * type adr_int32
1066 * ip address adr_u_char*type
1067 *
1068 */
1069 int
1070 subject32_ex_token(parse_context_t *ctx)
1071 {
1072 int32_t port; /* not used in output */
1073
1074 common_subject(ctx);
1075
1076 adrm_int32(&(ctx->adr), &port, 1);
1077 adrm_u_int32(&(ctx->adr), &(ctx->out.sf_tid.at_type), 1);
1078 adrm_u_char(&(ctx->adr), (uchar_t *)&(ctx->out.sf_tid.at_addr[0]),
1079 ctx->out.sf_tid.at_type);
1080
1081 return (0);
1082 }
1083
1084 /*
1085 * Format of subject64 token:
1086 * subject token id adr_char
1087 * auid adr_int32
1088 * euid adr_int32
1089 * egid adr_int32
1090 * ruid adr_int32
1091 * rgid adr_int32
1092 * pid adr_int32
1093 * sid adr_int32
1094 * termid adr_int64+adr_int32
1095 *
1096 */
1097 int
1098 subject64_token(parse_context_t *ctx)
1099 {
1100 int64_t port;
1101
1102 common_subject(ctx);
1103
1104 adrm_int64(&(ctx->adr), &port, 1);
1105 ctx->out.sf_tid.at_type = AU_IPv4;
1106 adrm_u_char(&(ctx->adr), (uchar_t *)&(ctx->out.sf_tid.at_addr[0]), 4);
1107
1108 return (0);
1109 }
1110
1111 /*
1112 * Format of subject64_ex token:
1113 * subject token id adr_char
1114 * auid adr_int32
1115 * euid adr_int32
1116 * egid adr_int32
1117 * ruid adr_int32
1118 * rgid adr_int32
1119 * pid adr_int32
1120 * sid adr_int32
1121 * termid
1122 * port adr_int64
1123 * type adr_int32
1124 * ip address adr_u_char*type
1125 *
1126 */
1127 int
1128 subject64_ex_token(parse_context_t *ctx)
1129 {
1130 int64_t port;
1131
1132 common_subject(ctx);
1133
1134 adrm_int64(&(ctx->adr), &port, 1);
1135 adrm_u_int32(&(ctx->adr), &(ctx->out.sf_tid.at_type), 1);
1136 adrm_u_char(&(ctx->adr), (uchar_t *)&(ctx->out.sf_tid.at_addr[0]),
1137 ctx->out.sf_tid.at_type);
1138
1139 return (0);
1140 }
1141
1142
1143 int
1144 xatom_token(parse_context_t *ctx)
1145 {
1146 skip_bytes(ctx);
1147
1148 return (0);
1149 }
1150
1151
1152 int
1153 xselect_token(parse_context_t *ctx)
1154 {
1155 skip_bytes(ctx);
1156 skip_bytes(ctx);
1157 skip_bytes(ctx);
1158
1159 return (0);
1160 }
1161
1162 /*
1163 * anchor a path name with a slash
1164 * assume we have enough space
1165 */
1166 static void
1167 anchor_path(char *path)
1168 {
1169
1170 (void) memmove((void *)(path + 1), (void *)path, strlen(path) + 1);
1171 *path = '/';
1172 }
1173
1174
1175 /*
1176 * copy path to collapsed path.
1177 * collapsed path does not contain:
1178 * successive slashes
1179 * instances of dot-slash
1180 * instances of dot-dot-slash
1181 * passed path must be anchored with a '/'
1182 */
1183 static size_t
1184 collapse_path(char *s, size_t ls)
1185 {
1186 int id; /* index of where we are in destination string */
1187 int is; /* index of where we are in source string */
1188 int slashseen; /* have we seen a slash */
1189
1190 ls++; /* source length including '\0' */
1191
1192 slashseen = 0;
1193 for (is = 0, id = 0; is < ls; is++) {
1194 if (s[is] == '\0') {
1195 if (id > 1 && s[id-1] == '/') {
1196 --id;
1197 }
1198 s[id++] = '\0';
1199 break;
1200 }
1201 /* previous character was a / */
1202 if (slashseen) {
1203 if (s[is] == '/')
1204 continue; /* another slash, ignore it */
1205 } else if (s[is] == '/') {
1206 /* we see a /, just copy it and try again */
1207 slashseen = 1;
1208 s[id++] = '/';
1209 continue;
1210 }
1211 /* /./ seen */
1212 if (s[is] == '.' && s[is+1] == '/') {
1213 is += 1;
1214 continue;
1215 }
1216 /* XXX/. seen */
1217 if (s[is] == '.' && s[is+1] == '\0') {
1218 if (id > 1)
1219 id--;
1220 continue;
1221 }
1222 /* XXX/.. seen */
1223 if (s[is] == '.' && s[is+1] == '.' && s[is+2] == '\0') {
1224 is += 1;
1225 if (id > 0)
1226 id--;
1227 while (id > 0 && s[--id] != '/')
1228 ;
1229 id++;
1230 continue;
1231 }
1232 /* XXX/../ seen */
1233 if (s[is] == '.' && s[is+1] == '.' && s[is+2] == '/') {
1234 is += 2;
1235 if (id > 0)
1236 id--;
1237 while (id > 0 && s[--id] != '/')
1238 ;
1239 id++;
1240 continue;
1241 }
1242 while (is < ls && (s[id++] = s[is++]) != '/')
1243 ;
1244 is--;
1245 }
1246 return ((size_t)id - 1);
1247 }
1248
1249 /*
1250 * for tokens with sub-fields that include a length, this
1251 * skips the sub-field.
1252 */
1253
1254 static void
1255 skip_bytes(parse_context_t *ctx)
1256 {
1257 ushort_t c;
1258
1259 adrm_u_short(&(ctx->adr), &c, 1);
1260 ctx->adr.adr_now += c;
1261 }
1262
1263 static void
1264 skip_string(parse_context_t *ctx)
1265 {
1266 char c;
1267
1268 do {
1269 adrm_char(&(ctx->adr), &c, 1);
1270 } while (c != (char)0);
1271 }
1272
1273 /*
1274 * add a byte to specified length so there can be a prefix of
1275 * '/' added (if needed for paths). Another is added for '\0'
1276 *
1277 * if offset is zero, new data overwrites old, if any. Otherwise
1278 * new data is appended to the end.
1279 */
1280
1281 static void
1282 get_bytes_to_string(parse_context_t *ctx, size_t *l, char **p,
1283 size_t offset)
1284 {
1285 ushort_t len;
1286 char *bp;
1287
1288 adrm_u_short(&(ctx->adr), &len, 1);
1289
1290 len++; /* in case need to add '/' prefix */
1291 *p = realloc(*p, 1 + (size_t)len + offset);
1292 if (*p == NULL) {
1293 perror("audit_sysudp.so");
1294 return;
1295 }
1296 if (offset > 0)
1297 offset--; /* overwrite end of string */
1298
1299 *l = (size_t)len - 2 + offset;
1300
1301 bp = *p + offset;
1302 adrm_char(&(ctx->adr), bp, len - 1);
1303 *(bp + len - 1) = '\0';
1304 }
1305
1306
1307 /*
1308 * Format of host token:
1309 * host adr_uint32
1310 */
1311 int
1312 host_token(parse_context_t *ctx)
1313 {
1314 ctx->adr.adr_now += sizeof (int32_t);
1315
1316 return (0);
1317 }
1318
1319 /*
1320 * Format of useofauth token:
1321 * uauth token id adr_char
1322 * uauth adr_string
1323 *
1324 */
1325 int
1326 useofauth_token(parse_context_t *ctx)
1327 {
1328 get_bytes_to_string(ctx, &(ctx->out.sf_uauthlen),
1329 &(ctx->out.sf_uauth), 0);
1330
1331 return (0);
1332 }
1333
1334 /*
1335 * Format of user token:
1336 * user token id adr_char
1337 * uid adr_uid
1338 * username adr_string
1339 *
1340 */
1341 int
1342 user_token(parse_context_t *ctx)
1343 {
1344 ctx->adr.adr_now += sizeof (uid_t);
1345 skip_bytes(ctx);
1346
1347 return (0);
1348 }
1349
1350 /*
1351 * Format of zonename token:
1352 * zonename token id adr_char
1353 * zonename adr_string
1354 *
1355 */
1356 int
1357 zonename_token(parse_context_t *ctx)
1358 {
1359 get_bytes_to_string(ctx,
1360 &(ctx->out.sf_zonelen),
1361 &(ctx->out.sf_zonename),
1362 0);
1363
1364 return (0);
1365 }
1366
1367 /*
1368 * Format of fmri token:
1369 * fmri token id adr_char
1370 * fmri adr_string
1371 */
1372 int
1373 fmri_token(parse_context_t *ctx)
1374 {
1375 skip_bytes(ctx);
1376
1377 return (0);
1378 }
1379
1380 int
1381 xcolormap_token(parse_context_t *ctx)
1382 {
1383 return (xgeneric(ctx));
1384 }
1385
1386 int
1387 xcursor_token(parse_context_t *ctx)
1388 {
1389 return (xgeneric(ctx));
1390 }
1391
1392 int
1393 xfont_token(parse_context_t *ctx)
1394 {
1395 return (xgeneric(ctx));
1396 }
1397
1398 int
1399 xgc_token(parse_context_t *ctx)
1400 {
1401 return (xgeneric(ctx));
1402 }
1403
1404 int
1405 xpixmap_token(parse_context_t *ctx)
1406 {
1407 return (xgeneric(ctx));
1408 }
1409
1410 int
1411 xwindow_token(parse_context_t *ctx)
1412 {
1413 return (xgeneric(ctx));
1414 }
1415 /*
1416 * Format of xgeneric token:
1417 * XID adr_int32
1418 * creator UID adr_int32
1419 *
1420 * Includes: xcolormap, xcursor, xfont, xgc, xpixmap, and xwindow
1421 */
1422 static int
1423 xgeneric(parse_context_t *ctx)
1424 {
1425 ctx->adr.adr_now += 2 * sizeof (int32_t);
1426
1427 return (0);
1428 }
1429 /*
1430 * Format of xproperty token:
1431 * XID adr_int32
1432 * creator UID adr_int32
1433 * atom string adr_string
1434 */
1435 int
1436 xproperty_token(parse_context_t *ctx)
1437 {
1438 ctx->adr.adr_now += 2 * sizeof (int32_t);
1439
1440 return (0);
1441 }
1442 /*
1443 * Format of xclient token:
1444 * xclient id adr_int32
1445 */
1446 int
1447 xclient_token(parse_context_t *ctx)
1448 {
1449 ctx->adr.adr_now += sizeof (int32_t);
1450
1451 return (0);
1452 }
1453
1454 /*
1455 * -----------------------------------------------------------------------
1456 * privilege_token() : Process privilege token and display contents
1457 *
1458 * Format of privilege token:
1459 * privilege token id adr_char
1460 * privilege type adr_string
1461 * privilege adr_string
1462 * -----------------------------------------------------------------------
1463 */
1464
1465 int
1466 privilege_token(parse_context_t *ctx)
1467 {
1468 skip_bytes(ctx);
1469 skip_bytes(ctx);
1470
1471 return (0);
1472 }
1473
1474
1475 /*
1476 * Format of label token:
1477 * label ID 1 byte
1478 * compartment length 1 byte
1479 * classification 2 bytes
1480 * compartment words <compartment length> * 4 bytes
1481 */
1482 int
1483 label_token(parse_context_t *ctx)
1484 {
1485 char c;
1486
1487 ctx->adr.adr_now += sizeof (char); /* label ID */
1488 adrm_char(&(ctx->adr), &c, 1);
1489
1490 ctx->adr.adr_now += sizeof (ushort_t); /* classification */
1491 ctx->adr.adr_now += 4 * c; /* compartments */
1492
1493 return (0);
1494 }
1495
1496 /*
1497 * Format of useofpriv token:
1498 * priv_type adr_char
1499 * priv_set_t adr_short
1500 * priv_set adr_char*(sizeof (priv_set_t))
1501 */
1502 int
1503 useofpriv_token(parse_context_t *ctx)
1504 {
1505 ctx->adr.adr_now += sizeof (char); /* success / fail */
1506 skip_bytes(ctx);
1507
1508 return (0);
1509 }