1 #include <getopt.h>
2 #include <unistd.h>
3 #include <stdlib.h>
4 #include <sys/mman.h>
5 #include <sys/types.h>
6 #include <sys/stat.h>
7 #include <fcntl.h>
8 #include <stdio.h>
9 #include <sepol/policydb/policydb.h>
10 #include <sepol/policydb/services.h>
11 #include <sepol/policydb/expand.h>
12
13 #define EQUALS 0
14 #define NOT 1
15 #define ANY 2
16
usage(char * arg0)17 void usage(char *arg0) {
18 fprintf(stderr, "%s -s <source> -t <target> -c <class> -p <perm> -P <policy file>\n", arg0);
19 exit(1);
20 }
21
cmalloc(size_t s)22 void *cmalloc(size_t s) {
23 void *t = malloc(s);
24 if (t == NULL) {
25 fprintf(stderr, "Out of memory\n");
26 exit(1);
27 }
28 return t;
29 }
30
parse_ops(char ** arg)31 int parse_ops(char **arg) {
32 switch (*arg[0]) {
33 case '-':
34 *arg = *arg + 1;
35 return NOT;
36 case '*':
37 return ANY;
38 default:
39 return EQUALS;
40 }
41 }
42
check(int op,uint16_t arg1,uint16_t arg2)43 int check(int op, uint16_t arg1, uint16_t arg2) {
44 switch (op) {
45 case EQUALS:
46 return arg1 == arg2;
47 case NOT:
48 return arg1 != arg2;
49 case ANY:
50 return 1;
51 default:
52 fprintf(stderr, "Bad op while checking!");
53 return 2;
54 }
55 }
56
check_perm(avtab_ptr_t current,perm_datum_t * perm)57 int check_perm(avtab_ptr_t current, perm_datum_t *perm) {
58 uint16_t perm_bitmask = 1U << (perm->s.value - 1);
59 return (current->datum.data & perm_bitmask) != 0;
60 }
61
62
expand_and_check(int s_op,uint32_t source_type,int t_op,uint32_t target_type,int c_op,uint32_t target_class,perm_datum_t * perm,policydb_t * policy,avtab_t * avtab)63 int expand_and_check(int s_op, uint32_t source_type,
64 int t_op, uint32_t target_type,
65 int c_op, uint32_t target_class,
66 perm_datum_t *perm, policydb_t *policy, avtab_t *avtab) {
67 avtab_t exp_avtab;
68 avtab_ptr_t cur;
69 unsigned int i;
70 int match;
71
72 if (avtab_init(&exp_avtab)) {
73 fputs("out of memory\n", stderr);
74 return -1;
75 }
76
77 if (expand_avtab(policy, avtab, &exp_avtab)) {
78 fputs("out of memory\n", stderr);
79 avtab_destroy(&exp_avtab);
80 return -1;
81 }
82
83 for (i = 0; i < exp_avtab.nslot; i++) {
84 for (cur = exp_avtab.htable[i]; cur; cur = cur->next) {
85 match = 1;
86 match &= check(s_op, source_type, cur->key.source_type);
87 match &= check(t_op, target_type, cur->key.target_type);
88 match &= check(c_op, target_class, cur->key.target_class);
89 match &= check_perm(cur, perm);
90 if (match) {
91 avtab_destroy(&exp_avtab);
92 return 1;
93 }
94 }
95 }
96
97 avtab_destroy(&exp_avtab);
98 return 0;
99 }
100
101 /*
102 * Checks to see if a rule matching the given arguments already exists.
103 *
104 * The format for the arguments is as follows:
105 *
106 * - A bare string is treated as a literal and will be matched by equality.
107 * - A string starting with "-" will be matched by inequality.
108 * - A string starting with "*" will be treated as a wildcard.
109 *
110 * The return codes for this function are as follows:
111 *
112 * - 0 indicates a successful return without a match
113 * - 1 indicates a successful return with a match
114 * - -1 indicates an error
115 */
check_rule(char * s,char * t,char * c,char * p,policydb_t * policy)116 int check_rule(char *s, char *t, char *c, char *p, policydb_t *policy) {
117 type_datum_t *src = NULL;
118 type_datum_t *tgt = NULL;
119 class_datum_t *cls = NULL;
120 perm_datum_t *perm = NULL;
121 int s_op = parse_ops(&s);
122 int t_op = parse_ops(&t);
123 int c_op = parse_ops(&c);
124 int p_op = parse_ops(&p);
125 avtab_key_t key;
126 int match;
127
128 key.source_type = key.target_type = key.target_class = 0;
129
130 if (s_op != ANY) {
131 src = hashtab_search(policy->p_types.table, s);
132 if (src == NULL) {
133 fprintf(stderr, "source type %s does not exist\n", s);
134 return -1;
135 }
136 }
137 if (t_op != ANY) {
138 tgt = hashtab_search(policy->p_types.table, t);
139 if (tgt == NULL) {
140 fprintf(stderr, "target type %s does not exist\n", t);
141 return -1;
142 }
143 }
144 if (c_op != ANY) {
145 cls = hashtab_search(policy->p_classes.table, c);
146 if (cls == NULL) {
147 fprintf(stderr, "class %s does not exist\n", c);
148 return -1;
149 }
150 }
151 if (p_op != ANY) {
152 perm = hashtab_search(cls->permissions.table, p);
153 if (perm == NULL) {
154 if (cls->comdatum == NULL) {
155 fprintf(stderr, "perm %s does not exist in class %s\n", p, c);
156 return -1;
157 }
158 perm = hashtab_search(cls->comdatum->permissions.table, p);
159 if (perm == NULL) {
160 fprintf(stderr, "perm %s does not exist in class %s\n", p, c);
161 return -1;
162 }
163 }
164 }
165
166 if (s_op != ANY)
167 key.source_type = src->s.value;
168 if (t_op != ANY)
169 key.target_type = tgt->s.value;
170 if (c_op != ANY)
171 key.target_class = cls->s.value;
172
173 /* Check unconditional rules after attribute expansion. */
174 match = expand_and_check(s_op, key.source_type,
175 t_op, key.target_type,
176 c_op, key.target_class,
177 perm, policy, &policy->te_avtab);
178 if (match)
179 return match;
180
181 /* Check conditional rules after attribute expansion. */
182 return expand_and_check(s_op, key.source_type,
183 t_op, key.target_type,
184 c_op, key.target_class,
185 perm, policy, &policy->te_cond_avtab);
186 }
187
load_policy(char * filename,policydb_t * policydb,struct policy_file * pf)188 int load_policy(char *filename, policydb_t *policydb, struct policy_file *pf) {
189 int fd;
190 struct stat sb;
191 void *map;
192 int ret;
193
194 fd = open(filename, O_RDONLY);
195 if (fd < 0) {
196 fprintf(stderr, "Can't open '%s': %s\n", filename, strerror(errno));
197 return 1;
198 }
199 if (fstat(fd, &sb) < 0) {
200 fprintf(stderr, "Can't stat '%s': %s\n", filename, strerror(errno));
201 close(fd);
202 return 1;
203 }
204 map = mmap(NULL, sb.st_size, PROT_READ | PROT_WRITE, MAP_PRIVATE, fd, 0);
205 if (map == MAP_FAILED) {
206 fprintf(stderr, "Can't mmap '%s': %s\n", filename, strerror(errno));
207 close(fd);
208 return 1;
209 }
210
211 policy_file_init(pf);
212 pf->type = PF_USE_MEMORY;
213 pf->data = map;
214 pf->len = sb.st_size;
215 if (policydb_init(policydb)) {
216 fprintf(stderr, "Could not initialize policydb!\n");
217 close(fd);
218 munmap(map, sb.st_size);
219 return 1;
220 }
221 ret = policydb_read(policydb, pf, 0);
222 if (ret) {
223 fprintf(stderr, "error(s) encountered while parsing configuration\n");
224 close(fd);
225 munmap(map, sb.st_size);
226 return 1;
227 }
228
229 return 0;
230 }
231
232
main(int argc,char ** argv)233 int main(int argc, char **argv)
234 {
235 char *policy = NULL, *source = NULL, *target = NULL, *class = NULL, *perm = NULL;
236 policydb_t policydb;
237 struct policy_file pf;
238 sidtab_t sidtab;
239 char ch;
240 int match = 1;
241
242 struct option long_options[] = {
243 {"source", required_argument, NULL, 's'},
244 {"target", required_argument, NULL, 't'},
245 {"class", required_argument, NULL, 'c'},
246 {"perm", required_argument, NULL, 'p'},
247 {"policy", required_argument, NULL, 'P'},
248 {NULL, 0, NULL, 0}
249 };
250
251 while ((ch = getopt_long(argc, argv, "s:t:c:p:P:", long_options, NULL)) != -1) {
252 switch (ch) {
253 case 's':
254 source = optarg;
255 break;
256 case 't':
257 target = optarg;
258 break;
259 case 'c':
260 class = optarg;
261 break;
262 case 'p':
263 perm = optarg;
264 break;
265 case 'P':
266 policy = optarg;
267 break;
268 default:
269 usage(argv[0]);
270 }
271 }
272
273 if (!source || !target || !class || !perm || !policy)
274 usage(argv[0]);
275
276 sepol_set_policydb(&policydb);
277 sepol_set_sidtab(&sidtab);
278
279 if (load_policy(policy, &policydb, &pf))
280 goto out;
281
282 match = check_rule(source, target, class, perm, &policydb);
283 if (match < 0) {
284 fprintf(stderr, "Error checking rules!\n");
285 goto out;
286 } else if (match > 0) {
287 printf("Match found!\n");
288 goto out;
289 }
290
291 match = 0;
292
293 out:
294 policydb_destroy(&policydb);
295 return match;
296 }
297