Home | History | Annotate | Download | only in src
      1 #include <unistd.h>
      2 #include <errno.h>
      3 #include <stdio.h>
      4 #include <stdio_ext.h>
      5 #include <stdlib.h>
      6 #include <string.h>
      7 #include <ctype.h>
      8 #include <pwd.h>
      9 #include "selinux_internal.h"
     10 #include "context_internal.h"
     11 #include "get_context_list_internal.h"
     12 
     13 int get_default_context_with_role(const char *user,
     14 				  const char *role,
     15 				  char * fromcon,
     16 				  char ** newcon)
     17 {
     18 	char **conary;
     19 	char **ptr;
     20 	context_t con;
     21 	const char *role2;
     22 	int rc;
     23 
     24 	rc = get_ordered_context_list(user, fromcon, &conary);
     25 	if (rc <= 0)
     26 		return -1;
     27 
     28 	for (ptr = conary; *ptr; ptr++) {
     29 		con = context_new(*ptr);
     30 		if (!con)
     31 			continue;
     32 		role2 = context_role_get(con);
     33 		if (role2 && !strcmp(role, role2)) {
     34 			context_free(con);
     35 			break;
     36 		}
     37 		context_free(con);
     38 	}
     39 
     40 	rc = -1;
     41 	if (!(*ptr)) {
     42 		errno = EINVAL;
     43 		goto out;
     44 	}
     45 	*newcon = strdup(*ptr);
     46 	if (!(*newcon))
     47 		goto out;
     48 	rc = 0;
     49       out:
     50 	freeconary(conary);
     51 	return rc;
     52 }
     53 
     54 hidden_def(get_default_context_with_role)
     55 
     56 int get_default_context_with_rolelevel(const char *user,
     57 				       const char *role,
     58 				       const char *level,
     59 				       char * fromcon,
     60 				       char ** newcon)
     61 {
     62 
     63 	int rc = 0;
     64 	int freefrom = 0;
     65 	context_t con;
     66 	char *newfromcon;
     67 	if (!level)
     68 		return get_default_context_with_role(user, role, fromcon,
     69 						     newcon);
     70 
     71 	if (!fromcon) {
     72 		rc = getcon(&fromcon);
     73 		if (rc < 0)
     74 			return rc;
     75 		freefrom = 1;
     76 	}
     77 
     78 	rc = -1;
     79 	con = context_new(fromcon);
     80 	if (!con)
     81 		goto out;
     82 
     83 	if (context_range_set(con, level))
     84 		goto out;
     85 
     86 	newfromcon = context_str(con);
     87 	if (!newfromcon)
     88 		goto out;
     89 
     90 	rc = get_default_context_with_role(user, role, newfromcon, newcon);
     91 
     92       out:
     93 	context_free(con);
     94 	if (freefrom)
     95 		freecon(fromcon);
     96 	return rc;
     97 
     98 }
     99 
    100 int get_default_context(const char *user,
    101 			char * fromcon, char ** newcon)
    102 {
    103 	char **conary;
    104 	int rc;
    105 
    106 	rc = get_ordered_context_list(user, fromcon, &conary);
    107 	if (rc <= 0)
    108 		return -1;
    109 
    110 	*newcon = strdup(conary[0]);
    111 	freeconary(conary);
    112 	if (!(*newcon))
    113 		return -1;
    114 	return 0;
    115 }
    116 
    117 static int find_partialcon(char ** list,
    118 			   unsigned int nreach, char *part)
    119 {
    120 	const char *conrole, *contype;
    121 	char *partrole, *parttype, *ptr;
    122 	context_t con;
    123 	unsigned int i;
    124 
    125 	partrole = part;
    126 	ptr = part;
    127 	while (*ptr && !isspace(*ptr) && *ptr != ':')
    128 		ptr++;
    129 	if (*ptr != ':')
    130 		return -1;
    131 	*ptr++ = 0;
    132 	parttype = ptr;
    133 	while (*ptr && !isspace(*ptr) && *ptr != ':')
    134 		ptr++;
    135 	*ptr = 0;
    136 
    137 	for (i = 0; i < nreach; i++) {
    138 		con = context_new(list[i]);
    139 		if (!con)
    140 			return -1;
    141 		conrole = context_role_get(con);
    142 		contype = context_type_get(con);
    143 		if (!conrole || !contype) {
    144 			context_free(con);
    145 			return -1;
    146 		}
    147 		if (!strcmp(conrole, partrole) && !strcmp(contype, parttype)) {
    148 			context_free(con);
    149 			return i;
    150 		}
    151 		context_free(con);
    152 	}
    153 
    154 	return -1;
    155 }
    156 
    157 static int get_context_order(FILE * fp,
    158 			     char * fromcon,
    159 			     char ** reachable,
    160 			     unsigned int nreach,
    161 			     unsigned int *ordering, unsigned int *nordered)
    162 {
    163 	char *start, *end = NULL;
    164 	char *line = NULL;
    165 	size_t line_len = 0;
    166 	ssize_t len;
    167 	int found = 0;
    168 	const char *fromrole, *fromtype;
    169 	char *linerole, *linetype;
    170 	unsigned int i;
    171 	context_t con;
    172 	int rc;
    173 
    174 	errno = -EINVAL;
    175 
    176 	/* Extract the role and type of the fromcon for matching.
    177 	   User identity and MLS range can be variable. */
    178 	con = context_new(fromcon);
    179 	if (!con)
    180 		return -1;
    181 	fromrole = context_role_get(con);
    182 	fromtype = context_type_get(con);
    183 	if (!fromrole || !fromtype) {
    184 		context_free(con);
    185 		return -1;
    186 	}
    187 
    188 	while ((len = getline(&line, &line_len, fp)) > 0) {
    189 		if (line[len - 1] == '\n')
    190 			line[len - 1] = 0;
    191 
    192 		/* Skip leading whitespace. */
    193 		start = line;
    194 		while (*start && isspace(*start))
    195 			start++;
    196 		if (!(*start))
    197 			continue;
    198 
    199 		/* Find the end of the (partial) fromcon in the line. */
    200 		end = start;
    201 		while (*end && !isspace(*end))
    202 			end++;
    203 		if (!(*end))
    204 			continue;
    205 
    206 		/* Check for a match. */
    207 		linerole = start;
    208 		while (*start && !isspace(*start) && *start != ':')
    209 			start++;
    210 		if (*start != ':')
    211 			continue;
    212 		*start = 0;
    213 		linetype = ++start;
    214 		while (*start && !isspace(*start) && *start != ':')
    215 			start++;
    216 		if (!(*start))
    217 			continue;
    218 		*start = 0;
    219 		if (!strcmp(fromrole, linerole) && !strcmp(fromtype, linetype)) {
    220 			found = 1;
    221 			break;
    222 		}
    223 	}
    224 
    225 	if (!found) {
    226 		errno = ENOENT;
    227 		rc = -1;
    228 		goto out;
    229 	}
    230 
    231 	start = ++end;
    232 	while (*start) {
    233 		/* Skip leading whitespace */
    234 		while (*start && isspace(*start))
    235 			start++;
    236 		if (!(*start))
    237 			break;
    238 
    239 		/* Find the end of this partial context. */
    240 		end = start;
    241 		while (*end && !isspace(*end))
    242 			end++;
    243 		if (*end)
    244 			*end++ = 0;
    245 
    246 		/* Check for a match in the reachable list. */
    247 		rc = find_partialcon(reachable, nreach, start);
    248 		if (rc < 0) {
    249 			/* No match, skip it. */
    250 			start = end;
    251 			continue;
    252 		}
    253 
    254 		/* If a match is found and the entry is not already ordered
    255 		   (e.g. due to prior match in prior config file), then set
    256 		   the ordering for it. */
    257 		i = rc;
    258 		if (ordering[i] == nreach)
    259 			ordering[i] = (*nordered)++;
    260 		start = end;
    261 	}
    262 
    263 	rc = 0;
    264 
    265       out:
    266 	context_free(con);
    267 	free(line);
    268 	return rc;
    269 }
    270 
    271 static int get_failsafe_context(const char *user, char ** newcon)
    272 {
    273 	FILE *fp;
    274 	char buf[255], *ptr;
    275 	size_t plen, nlen;
    276 	int rc;
    277 
    278 	fp = fopen(selinux_failsafe_context_path(), "r");
    279 	if (!fp)
    280 		return -1;
    281 
    282 	ptr = fgets_unlocked(buf, sizeof buf, fp);
    283 	fclose(fp);
    284 
    285 	if (!ptr)
    286 		return -1;
    287 	plen = strlen(ptr);
    288 	if (buf[plen - 1] == '\n')
    289 		buf[plen - 1] = 0;
    290 
    291 	nlen = strlen(user) + 1 + plen + 1;
    292 	*newcon = malloc(nlen);
    293 	if (!(*newcon))
    294 		return -1;
    295 	rc = snprintf(*newcon, nlen, "%s:%s", user, ptr);
    296 	if (rc < 0 || (size_t) rc >= nlen) {
    297 		free(*newcon);
    298 		*newcon = 0;
    299 		return -1;
    300 	}
    301 
    302 	/* If possible, check the context to catch
    303 	   errors early rather than waiting until the
    304 	   caller tries to use setexeccon on the context.
    305 	   But this may not always be possible, e.g. if
    306 	   selinuxfs isn't mounted. */
    307 	if (security_check_context(*newcon) && errno != ENOENT) {
    308 		free(*newcon);
    309 		*newcon = 0;
    310 		return -1;
    311 	}
    312 
    313 	return 0;
    314 }
    315 
    316 struct context_order {
    317 	char * con;
    318 	unsigned int order;
    319 };
    320 
    321 static int order_compare(const void *A, const void *B)
    322 {
    323 	const struct context_order *c1 = A, *c2 = B;
    324 	if (c1->order < c2->order)
    325 		return -1;
    326 	else if (c1->order > c2->order)
    327 		return 1;
    328 	return strcmp(c1->con, c2->con);
    329 }
    330 
    331 int get_ordered_context_list_with_level(const char *user,
    332 					const char *level,
    333 					char * fromcon,
    334 					char *** list)
    335 {
    336 	int rc;
    337 	int freefrom = 0;
    338 	context_t con;
    339 	char *newfromcon;
    340 
    341 	if (!level)
    342 		return get_ordered_context_list(user, fromcon, list);
    343 
    344 	if (!fromcon) {
    345 		rc = getcon(&fromcon);
    346 		if (rc < 0)
    347 			return rc;
    348 		freefrom = 1;
    349 	}
    350 
    351 	rc = -1;
    352 	con = context_new(fromcon);
    353 	if (!con)
    354 		goto out;
    355 
    356 	if (context_range_set(con, level))
    357 		goto out;
    358 
    359 	newfromcon = context_str(con);
    360 	if (!newfromcon)
    361 		goto out;
    362 
    363 	rc = get_ordered_context_list(user, newfromcon, list);
    364 
    365       out:
    366 	context_free(con);
    367 	if (freefrom)
    368 		freecon(fromcon);
    369 	return rc;
    370 }
    371 
    372 hidden_def(get_ordered_context_list_with_level)
    373 
    374 int get_default_context_with_level(const char *user,
    375 				   const char *level,
    376 				   char * fromcon,
    377 				   char ** newcon)
    378 {
    379 	char **conary;
    380 	int rc;
    381 
    382 	rc = get_ordered_context_list_with_level(user, level, fromcon, &conary);
    383 	if (rc <= 0)
    384 		return -1;
    385 
    386 	*newcon = strdup(conary[0]);
    387 	freeconary(conary);
    388 	if (!(*newcon))
    389 		return -1;
    390 	return 0;
    391 }
    392 
    393 int get_ordered_context_list(const char *user,
    394 			     char * fromcon,
    395 			     char *** list)
    396 {
    397 	char **reachable = NULL;
    398 	unsigned int *ordering = NULL;
    399 	struct context_order *co = NULL;
    400 	char **ptr;
    401 	int rc = 0;
    402 	unsigned int nreach = 0, nordered = 0, freefrom = 0, i;
    403 	FILE *fp;
    404 	char *fname = NULL;
    405 	size_t fname_len;
    406 	const char *user_contexts_path = selinux_user_contexts_path();
    407 
    408 	if (!fromcon) {
    409 		/* Get the current context and use it for the starting context */
    410 		rc = getcon(&fromcon);
    411 		if (rc < 0)
    412 			return rc;
    413 		freefrom = 1;
    414 	}
    415 
    416 	/* Determine the set of reachable contexts for the user. */
    417 	rc = security_compute_user(fromcon, user, &reachable);
    418 	if (rc < 0)
    419 		goto failsafe;
    420 	nreach = 0;
    421 	for (ptr = reachable; *ptr; ptr++)
    422 		nreach++;
    423 	if (!nreach)
    424 		goto failsafe;
    425 
    426 	/* Initialize ordering array. */
    427 	ordering = malloc(nreach * sizeof(unsigned int));
    428 	if (!ordering)
    429 		goto failsafe;
    430 	for (i = 0; i < nreach; i++)
    431 		ordering[i] = nreach;
    432 
    433 	/* Determine the ordering to apply from the optional per-user config
    434 	   and from the global config. */
    435 	fname_len = strlen(user_contexts_path) + strlen(user) + 2;
    436 	fname = malloc(fname_len);
    437 	if (!fname)
    438 		goto failsafe;
    439 	snprintf(fname, fname_len, "%s%s", user_contexts_path, user);
    440 	fp = fopen(fname, "r");
    441 	if (fp) {
    442 		__fsetlocking(fp, FSETLOCKING_BYCALLER);
    443 		rc = get_context_order(fp, fromcon, reachable, nreach, ordering,
    444 				       &nordered);
    445 		fclose(fp);
    446 		if (rc < 0 && errno != ENOENT) {
    447 			fprintf(stderr,
    448 				"%s:  error in processing configuration file %s\n",
    449 				__FUNCTION__, fname);
    450 			/* Fall through, try global config */
    451 		}
    452 	}
    453 	free(fname);
    454 	fp = fopen(selinux_default_context_path(), "r");
    455 	if (fp) {
    456 		__fsetlocking(fp, FSETLOCKING_BYCALLER);
    457 		rc = get_context_order(fp, fromcon, reachable, nreach, ordering,
    458 				       &nordered);
    459 		fclose(fp);
    460 		if (rc < 0 && errno != ENOENT) {
    461 			fprintf(stderr,
    462 				"%s:  error in processing configuration file %s\n",
    463 				__FUNCTION__, selinux_default_context_path());
    464 			/* Fall through */
    465 		}
    466 		rc = 0;
    467 	}
    468 
    469 	if (!nordered)
    470 		goto failsafe;
    471 
    472 	/* Apply the ordering. */
    473 	co = malloc(nreach * sizeof(struct context_order));
    474 	if (!co)
    475 		goto failsafe;
    476 	for (i = 0; i < nreach; i++) {
    477 		co[i].con = reachable[i];
    478 		co[i].order = ordering[i];
    479 	}
    480 	qsort(co, nreach, sizeof(struct context_order), order_compare);
    481 	for (i = 0; i < nreach; i++)
    482 		reachable[i] = co[i].con;
    483 	free(co);
    484 
    485 	/* Only report the ordered entries to the caller. */
    486 	if (nordered <= nreach) {
    487 		for (i = nordered; i < nreach; i++)
    488 			free(reachable[i]);
    489 		reachable[nordered] = NULL;
    490 		rc = nordered;
    491 	}
    492 
    493       out:
    494 	if (rc > 0)
    495 		*list = reachable;
    496 	else
    497 		freeconary(reachable);
    498 
    499 	free(ordering);
    500 	if (freefrom)
    501 		freecon(fromcon);
    502 
    503 	return rc;
    504 
    505       failsafe:
    506 	/* Unable to determine a reachable context list, try to fall back to
    507 	   the "failsafe" context to at least permit root login
    508 	   for emergency recovery if possible. */
    509 	freeconary(reachable);
    510 	reachable = malloc(2 * sizeof(char *));
    511 	if (!reachable) {
    512 		rc = -1;
    513 		goto out;
    514 	}
    515 	reachable[0] = reachable[1] = 0;
    516 	rc = get_failsafe_context(user, &reachable[0]);
    517 	if (rc < 0) {
    518 		freeconary(reachable);
    519 		reachable = NULL;
    520 		goto out;
    521 	}
    522 	rc = 1;			/* one context in the list */
    523 	goto out;
    524 }
    525 
    526 hidden_def(get_ordered_context_list)
    527