2 * security/tomoyo/domain.c
4 * Implementation of the Domain-Based Mandatory Access Control.
6 * Copyright (C) 2005-2009 NTT DATA CORPORATION
8 * Version: 2.2.0 2009/04/01
15 #include <linux/binfmts.h>
17 /* Variables definitions.*/
19 /* The initial domain. */
20 struct tomoyo_domain_info tomoyo_kernel_domain;
22 /* The list for "struct tomoyo_domain_info". */
23 LIST_HEAD(tomoyo_domain_list);
24 DECLARE_RWSEM(tomoyo_domain_list_lock);
26 /* Structure for "initialize_domain" and "no_initialize_domain" keyword. */
27 struct tomoyo_domain_initializer_entry {
28 struct list_head list;
29 const struct tomoyo_path_info *domainname; /* This may be NULL */
30 const struct tomoyo_path_info *program;
32 bool is_not; /* True if this entry is "no_initialize_domain". */
33 /* True if the domainname is tomoyo_get_last_name(). */
37 /* Structure for "keep_domain" and "no_keep_domain" keyword. */
38 struct tomoyo_domain_keeper_entry {
39 struct list_head list;
40 const struct tomoyo_path_info *domainname;
41 const struct tomoyo_path_info *program; /* This may be NULL */
43 bool is_not; /* True if this entry is "no_keep_domain". */
44 /* True if the domainname is tomoyo_get_last_name(). */
48 /* Structure for "alias" keyword. */
49 struct tomoyo_alias_entry {
50 struct list_head list;
51 const struct tomoyo_path_info *original_name;
52 const struct tomoyo_path_info *aliased_name;
57 * tomoyo_set_domain_flag - Set or clear domain's attribute flags.
59 * @domain: Pointer to "struct tomoyo_domain_info".
60 * @is_delete: True if it is a delete request.
61 * @flags: Flags to set or clear.
65 void tomoyo_set_domain_flag(struct tomoyo_domain_info *domain,
66 const bool is_delete, const u8 flags)
68 /* We need to serialize because this is bitfield operation. */
69 static DEFINE_SPINLOCK(lock);
70 /***** CRITICAL SECTION START *****/
73 domain->flags |= flags;
75 domain->flags &= ~flags;
77 /***** CRITICAL SECTION END *****/
81 * tomoyo_get_last_name - Get last component of a domainname.
83 * @domain: Pointer to "struct tomoyo_domain_info".
85 * Returns the last component of the domainname.
87 const char *tomoyo_get_last_name(const struct tomoyo_domain_info *domain)
89 const char *cp0 = domain->domainname->name;
90 const char *cp1 = strrchr(cp0, ' ');
97 /* The list for "struct tomoyo_domain_initializer_entry". */
98 static LIST_HEAD(tomoyo_domain_initializer_list);
99 static DECLARE_RWSEM(tomoyo_domain_initializer_list_lock);
102 * tomoyo_update_domain_initializer_entry - Update "struct tomoyo_domain_initializer_entry" list.
104 * @domainname: The name of domain. May be NULL.
105 * @program: The name of program.
106 * @is_not: True if it is "no_initialize_domain" entry.
107 * @is_delete: True if it is a delete request.
109 * Returns 0 on success, negative value otherwise.
111 static int tomoyo_update_domain_initializer_entry(const char *domainname,
114 const bool is_delete)
116 struct tomoyo_domain_initializer_entry *new_entry;
117 struct tomoyo_domain_initializer_entry *ptr;
118 const struct tomoyo_path_info *saved_program;
119 const struct tomoyo_path_info *saved_domainname = NULL;
121 bool is_last_name = false;
123 if (!tomoyo_is_correct_path(program, 1, -1, -1, __func__))
124 return -EINVAL; /* No patterns allowed. */
126 if (!tomoyo_is_domain_def(domainname) &&
127 tomoyo_is_correct_path(domainname, 1, -1, -1, __func__))
129 else if (!tomoyo_is_correct_domain(domainname, __func__))
131 saved_domainname = tomoyo_save_name(domainname);
132 if (!saved_domainname)
135 saved_program = tomoyo_save_name(program);
138 /***** EXCLUSIVE SECTION START *****/
139 down_write(&tomoyo_domain_initializer_list_lock);
140 list_for_each_entry(ptr, &tomoyo_domain_initializer_list, list) {
141 if (ptr->is_not != is_not ||
142 ptr->domainname != saved_domainname ||
143 ptr->program != saved_program)
145 ptr->is_deleted = is_delete;
153 new_entry = tomoyo_alloc_element(sizeof(*new_entry));
156 new_entry->domainname = saved_domainname;
157 new_entry->program = saved_program;
158 new_entry->is_not = is_not;
159 new_entry->is_last_name = is_last_name;
160 list_add_tail(&new_entry->list, &tomoyo_domain_initializer_list);
163 up_write(&tomoyo_domain_initializer_list_lock);
164 /***** EXCLUSIVE SECTION END *****/
169 * tomoyo_read_domain_initializer_policy - Read "struct tomoyo_domain_initializer_entry" list.
171 * @head: Pointer to "struct tomoyo_io_buffer".
173 * Returns true on success, false otherwise.
175 bool tomoyo_read_domain_initializer_policy(struct tomoyo_io_buffer *head)
177 struct list_head *pos;
180 down_read(&tomoyo_domain_initializer_list_lock);
181 list_for_each_cookie(pos, head->read_var2,
182 &tomoyo_domain_initializer_list) {
184 const char *from = "";
185 const char *domain = "";
186 struct tomoyo_domain_initializer_entry *ptr;
187 ptr = list_entry(pos, struct tomoyo_domain_initializer_entry,
191 no = ptr->is_not ? "no_" : "";
192 if (ptr->domainname) {
194 domain = ptr->domainname->name;
196 if (!tomoyo_io_printf(head,
197 "%s" TOMOYO_KEYWORD_INITIALIZE_DOMAIN
198 "%s%s%s\n", no, ptr->program->name, from,
204 up_read(&tomoyo_domain_initializer_list_lock);
209 * tomoyo_write_domain_initializer_policy - Write "struct tomoyo_domain_initializer_entry" list.
211 * @data: String to parse.
212 * @is_not: True if it is "no_initialize_domain" entry.
213 * @is_delete: True if it is a delete request.
215 * Returns 0 on success, negative value otherwise.
217 int tomoyo_write_domain_initializer_policy(char *data, const bool is_not,
218 const bool is_delete)
220 char *cp = strstr(data, " from ");
224 return tomoyo_update_domain_initializer_entry(cp + 6, data,
228 return tomoyo_update_domain_initializer_entry(NULL, data, is_not,
233 * tomoyo_is_domain_initializer - Check whether the given program causes domainname reinitialization.
235 * @domainname: The name of domain.
236 * @program: The name of program.
237 * @last_name: The last component of @domainname.
239 * Returns true if executing @program reinitializes domain transition,
242 static bool tomoyo_is_domain_initializer(const struct tomoyo_path_info *
244 const struct tomoyo_path_info *program,
245 const struct tomoyo_path_info *
248 struct tomoyo_domain_initializer_entry *ptr;
251 down_read(&tomoyo_domain_initializer_list_lock);
252 list_for_each_entry(ptr, &tomoyo_domain_initializer_list, list) {
255 if (ptr->domainname) {
256 if (!ptr->is_last_name) {
257 if (ptr->domainname != domainname)
260 if (tomoyo_pathcmp(ptr->domainname, last_name))
264 if (tomoyo_pathcmp(ptr->program, program))
272 up_read(&tomoyo_domain_initializer_list_lock);
276 /* The list for "struct tomoyo_domain_keeper_entry". */
277 static LIST_HEAD(tomoyo_domain_keeper_list);
278 static DECLARE_RWSEM(tomoyo_domain_keeper_list_lock);
281 * tomoyo_update_domain_keeper_entry - Update "struct tomoyo_domain_keeper_entry" list.
283 * @domainname: The name of domain.
284 * @program: The name of program. May be NULL.
285 * @is_not: True if it is "no_keep_domain" entry.
286 * @is_delete: True if it is a delete request.
288 * Returns 0 on success, negative value otherwise.
290 static int tomoyo_update_domain_keeper_entry(const char *domainname,
293 const bool is_delete)
295 struct tomoyo_domain_keeper_entry *new_entry;
296 struct tomoyo_domain_keeper_entry *ptr;
297 const struct tomoyo_path_info *saved_domainname;
298 const struct tomoyo_path_info *saved_program = NULL;
300 bool is_last_name = false;
302 if (!tomoyo_is_domain_def(domainname) &&
303 tomoyo_is_correct_path(domainname, 1, -1, -1, __func__))
305 else if (!tomoyo_is_correct_domain(domainname, __func__))
308 if (!tomoyo_is_correct_path(program, 1, -1, -1, __func__))
310 saved_program = tomoyo_save_name(program);
314 saved_domainname = tomoyo_save_name(domainname);
315 if (!saved_domainname)
317 /***** EXCLUSIVE SECTION START *****/
318 down_write(&tomoyo_domain_keeper_list_lock);
319 list_for_each_entry(ptr, &tomoyo_domain_keeper_list, list) {
320 if (ptr->is_not != is_not ||
321 ptr->domainname != saved_domainname ||
322 ptr->program != saved_program)
324 ptr->is_deleted = is_delete;
332 new_entry = tomoyo_alloc_element(sizeof(*new_entry));
335 new_entry->domainname = saved_domainname;
336 new_entry->program = saved_program;
337 new_entry->is_not = is_not;
338 new_entry->is_last_name = is_last_name;
339 list_add_tail(&new_entry->list, &tomoyo_domain_keeper_list);
342 up_write(&tomoyo_domain_keeper_list_lock);
343 /***** EXCLUSIVE SECTION END *****/
348 * tomoyo_write_domain_keeper_policy - Write "struct tomoyo_domain_keeper_entry" list.
350 * @data: String to parse.
351 * @is_not: True if it is "no_keep_domain" entry.
352 * @is_delete: True if it is a delete request.
355 int tomoyo_write_domain_keeper_policy(char *data, const bool is_not,
356 const bool is_delete)
358 char *cp = strstr(data, " from ");
362 return tomoyo_update_domain_keeper_entry(cp + 6, data, is_not,
365 return tomoyo_update_domain_keeper_entry(data, NULL, is_not, is_delete);
369 * tomoyo_read_domain_keeper_policy - Read "struct tomoyo_domain_keeper_entry" list.
371 * @head: Pointer to "struct tomoyo_io_buffer".
373 * Returns true on success, false otherwise.
375 bool tomoyo_read_domain_keeper_policy(struct tomoyo_io_buffer *head)
377 struct list_head *pos;
380 down_read(&tomoyo_domain_keeper_list_lock);
381 list_for_each_cookie(pos, head->read_var2,
382 &tomoyo_domain_keeper_list) {
383 struct tomoyo_domain_keeper_entry *ptr;
385 const char *from = "";
386 const char *program = "";
388 ptr = list_entry(pos, struct tomoyo_domain_keeper_entry, list);
391 no = ptr->is_not ? "no_" : "";
394 program = ptr->program->name;
396 if (!tomoyo_io_printf(head,
397 "%s" TOMOYO_KEYWORD_KEEP_DOMAIN
398 "%s%s%s\n", no, program, from,
399 ptr->domainname->name)) {
404 up_read(&tomoyo_domain_keeper_list_lock);
409 * tomoyo_is_domain_keeper - Check whether the given program causes domain transition suppression.
411 * @domainname: The name of domain.
412 * @program: The name of program.
413 * @last_name: The last component of @domainname.
415 * Returns true if executing @program supresses domain transition,
418 static bool tomoyo_is_domain_keeper(const struct tomoyo_path_info *domainname,
419 const struct tomoyo_path_info *program,
420 const struct tomoyo_path_info *last_name)
422 struct tomoyo_domain_keeper_entry *ptr;
425 down_read(&tomoyo_domain_keeper_list_lock);
426 list_for_each_entry(ptr, &tomoyo_domain_keeper_list, list) {
429 if (!ptr->is_last_name) {
430 if (ptr->domainname != domainname)
433 if (tomoyo_pathcmp(ptr->domainname, last_name))
436 if (ptr->program && tomoyo_pathcmp(ptr->program, program))
444 up_read(&tomoyo_domain_keeper_list_lock);
448 /* The list for "struct tomoyo_alias_entry". */
449 static LIST_HEAD(tomoyo_alias_list);
450 static DECLARE_RWSEM(tomoyo_alias_list_lock);
453 * tomoyo_update_alias_entry - Update "struct tomoyo_alias_entry" list.
455 * @original_name: The original program's real name.
456 * @aliased_name: The symbolic program's symbolic link's name.
457 * @is_delete: True if it is a delete request.
459 * Returns 0 on success, negative value otherwise.
461 static int tomoyo_update_alias_entry(const char *original_name,
462 const char *aliased_name,
463 const bool is_delete)
465 struct tomoyo_alias_entry *new_entry;
466 struct tomoyo_alias_entry *ptr;
467 const struct tomoyo_path_info *saved_original_name;
468 const struct tomoyo_path_info *saved_aliased_name;
471 if (!tomoyo_is_correct_path(original_name, 1, -1, -1, __func__) ||
472 !tomoyo_is_correct_path(aliased_name, 1, -1, -1, __func__))
473 return -EINVAL; /* No patterns allowed. */
474 saved_original_name = tomoyo_save_name(original_name);
475 saved_aliased_name = tomoyo_save_name(aliased_name);
476 if (!saved_original_name || !saved_aliased_name)
478 /***** EXCLUSIVE SECTION START *****/
479 down_write(&tomoyo_alias_list_lock);
480 list_for_each_entry(ptr, &tomoyo_alias_list, list) {
481 if (ptr->original_name != saved_original_name ||
482 ptr->aliased_name != saved_aliased_name)
484 ptr->is_deleted = is_delete;
492 new_entry = tomoyo_alloc_element(sizeof(*new_entry));
495 new_entry->original_name = saved_original_name;
496 new_entry->aliased_name = saved_aliased_name;
497 list_add_tail(&new_entry->list, &tomoyo_alias_list);
500 up_write(&tomoyo_alias_list_lock);
501 /***** EXCLUSIVE SECTION END *****/
506 * tomoyo_read_alias_policy - Read "struct tomoyo_alias_entry" list.
508 * @head: Pointer to "struct tomoyo_io_buffer".
510 * Returns true on success, false otherwise.
512 bool tomoyo_read_alias_policy(struct tomoyo_io_buffer *head)
514 struct list_head *pos;
517 down_read(&tomoyo_alias_list_lock);
518 list_for_each_cookie(pos, head->read_var2, &tomoyo_alias_list) {
519 struct tomoyo_alias_entry *ptr;
521 ptr = list_entry(pos, struct tomoyo_alias_entry, list);
524 if (!tomoyo_io_printf(head, TOMOYO_KEYWORD_ALIAS "%s %s\n",
525 ptr->original_name->name,
526 ptr->aliased_name->name)) {
531 up_read(&tomoyo_alias_list_lock);
536 * tomoyo_write_alias_policy - Write "struct tomoyo_alias_entry" list.
538 * @data: String to parse.
539 * @is_delete: True if it is a delete request.
541 * Returns 0 on success, negative value otherwise.
543 int tomoyo_write_alias_policy(char *data, const bool is_delete)
545 char *cp = strchr(data, ' ');
550 return tomoyo_update_alias_entry(data, cp, is_delete);
553 /* Domain create/delete handler. */
556 * tomoyo_delete_domain - Delete a domain.
558 * @domainname: The name of domain.
562 int tomoyo_delete_domain(char *domainname)
564 struct tomoyo_domain_info *domain;
565 struct tomoyo_path_info name;
567 name.name = domainname;
568 tomoyo_fill_path_info(&name);
569 /***** EXCLUSIVE SECTION START *****/
570 down_write(&tomoyo_domain_list_lock);
571 /* Is there an active domain? */
572 list_for_each_entry(domain, &tomoyo_domain_list, list) {
573 /* Never delete tomoyo_kernel_domain */
574 if (domain == &tomoyo_kernel_domain)
576 if (domain->is_deleted ||
577 tomoyo_pathcmp(domain->domainname, &name))
579 domain->is_deleted = true;
582 up_write(&tomoyo_domain_list_lock);
583 /***** EXCLUSIVE SECTION END *****/
588 * tomoyo_find_or_assign_new_domain - Create a domain.
590 * @domainname: The name of domain.
591 * @profile: Profile number to assign if the domain was newly created.
593 * Returns pointer to "struct tomoyo_domain_info" on success, NULL otherwise.
595 struct tomoyo_domain_info *tomoyo_find_or_assign_new_domain(const char *
599 struct tomoyo_domain_info *domain = NULL;
600 const struct tomoyo_path_info *saved_domainname;
602 /***** EXCLUSIVE SECTION START *****/
603 down_write(&tomoyo_domain_list_lock);
604 domain = tomoyo_find_domain(domainname);
607 if (!tomoyo_is_correct_domain(domainname, __func__))
609 saved_domainname = tomoyo_save_name(domainname);
610 if (!saved_domainname)
612 /* Can I reuse memory of deleted domain? */
613 list_for_each_entry(domain, &tomoyo_domain_list, list) {
614 struct task_struct *p;
615 struct tomoyo_acl_info *ptr;
617 if (!domain->is_deleted ||
618 domain->domainname != saved_domainname)
621 /***** CRITICAL SECTION START *****/
622 read_lock(&tasklist_lock);
623 for_each_process(p) {
624 if (tomoyo_real_domain(p) != domain)
629 read_unlock(&tasklist_lock);
630 /***** CRITICAL SECTION END *****/
633 list_for_each_entry(ptr, &domain->acl_info_list, list) {
634 ptr->type |= TOMOYO_ACL_DELETED;
636 tomoyo_set_domain_flag(domain, true, domain->flags);
637 domain->profile = profile;
638 domain->quota_warned = false;
639 mb(); /* Avoid out-of-order execution. */
640 domain->is_deleted = false;
643 /* No memory reusable. Create using new memory. */
644 domain = tomoyo_alloc_element(sizeof(*domain));
646 INIT_LIST_HEAD(&domain->acl_info_list);
647 domain->domainname = saved_domainname;
648 domain->profile = profile;
649 list_add_tail(&domain->list, &tomoyo_domain_list);
652 up_write(&tomoyo_domain_list_lock);
653 /***** EXCLUSIVE SECTION END *****/
658 * tomoyo_find_next_domain - Find a domain.
660 * @bprm: Pointer to "struct linux_binprm".
661 * @next_domain: Pointer to pointer to "struct tomoyo_domain_info".
663 * Returns 0 on success, negative value otherwise.
665 int tomoyo_find_next_domain(struct linux_binprm *bprm,
666 struct tomoyo_domain_info **next_domain)
669 * This function assumes that the size of buffer returned by
670 * tomoyo_realpath() = TOMOYO_MAX_PATHNAME_LEN.
672 struct tomoyo_page_buffer *tmp = tomoyo_alloc(sizeof(*tmp));
673 struct tomoyo_domain_info *old_domain = tomoyo_domain();
674 struct tomoyo_domain_info *domain = NULL;
675 const char *old_domain_name = old_domain->domainname->name;
676 const char *original_name = bprm->filename;
677 char *new_domain_name = NULL;
678 char *real_program_name = NULL;
679 char *symlink_program_name = NULL;
680 const u8 mode = tomoyo_check_flags(old_domain, TOMOYO_MAC_FOR_FILE);
681 const bool is_enforce = (mode == 3);
682 int retval = -ENOMEM;
683 struct tomoyo_path_info r; /* real name */
684 struct tomoyo_path_info s; /* symlink name */
685 struct tomoyo_path_info l; /* last name */
686 static bool initialized;
693 * Built-in initializers. This is needed because policies are
694 * not loaded until starting /sbin/init.
696 tomoyo_update_domain_initializer_entry(NULL, "/sbin/hotplug",
698 tomoyo_update_domain_initializer_entry(NULL, "/sbin/modprobe",
703 /* Get tomoyo_realpath of program. */
705 /* I hope tomoyo_realpath() won't fail with -ENOMEM. */
706 real_program_name = tomoyo_realpath(original_name);
707 if (!real_program_name)
709 /* Get tomoyo_realpath of symbolic link. */
710 symlink_program_name = tomoyo_realpath_nofollow(original_name);
711 if (!symlink_program_name)
714 r.name = real_program_name;
715 tomoyo_fill_path_info(&r);
716 s.name = symlink_program_name;
717 tomoyo_fill_path_info(&s);
718 l.name = tomoyo_get_last_name(old_domain);
719 tomoyo_fill_path_info(&l);
721 /* Check 'alias' directive. */
722 if (tomoyo_pathcmp(&r, &s)) {
723 struct tomoyo_alias_entry *ptr;
724 /* Is this program allowed to be called via symbolic links? */
725 down_read(&tomoyo_alias_list_lock);
726 list_for_each_entry(ptr, &tomoyo_alias_list, list) {
727 if (ptr->is_deleted ||
728 tomoyo_pathcmp(&r, ptr->original_name) ||
729 tomoyo_pathcmp(&s, ptr->aliased_name))
731 memset(real_program_name, 0, TOMOYO_MAX_PATHNAME_LEN);
732 strncpy(real_program_name, ptr->aliased_name->name,
733 TOMOYO_MAX_PATHNAME_LEN - 1);
734 tomoyo_fill_path_info(&r);
737 up_read(&tomoyo_alias_list_lock);
740 /* Check execute permission. */
741 retval = tomoyo_check_exec_perm(old_domain, &r, tmp);
745 new_domain_name = tmp->buffer;
746 if (tomoyo_is_domain_initializer(old_domain->domainname, &r, &l)) {
747 /* Transit to the child of tomoyo_kernel_domain domain. */
748 snprintf(new_domain_name, TOMOYO_MAX_PATHNAME_LEN + 1,
749 TOMOYO_ROOT_NAME " " "%s", real_program_name);
750 } else if (old_domain == &tomoyo_kernel_domain &&
751 !tomoyo_policy_loaded) {
753 * Needn't to transit from kernel domain before starting
754 * /sbin/init. But transit from kernel domain if executing
755 * initializers because they might start before /sbin/init.
758 } else if (tomoyo_is_domain_keeper(old_domain->domainname, &r, &l)) {
759 /* Keep current domain. */
762 /* Normal domain transition. */
763 snprintf(new_domain_name, TOMOYO_MAX_PATHNAME_LEN + 1,
764 "%s %s", old_domain_name, real_program_name);
766 if (domain || strlen(new_domain_name) >= TOMOYO_MAX_PATHNAME_LEN)
768 down_read(&tomoyo_domain_list_lock);
769 domain = tomoyo_find_domain(new_domain_name);
770 up_read(&tomoyo_domain_list_lock);
775 domain = tomoyo_find_or_assign_new_domain(new_domain_name,
776 old_domain->profile);
780 printk(KERN_WARNING "TOMOYO-ERROR: Domain '%s' not defined.\n",
785 tomoyo_set_domain_flag(old_domain, false,
786 TOMOYO_DOMAIN_FLAGS_TRANSITION_FAILED);
788 tomoyo_free(real_program_name);
789 tomoyo_free(symlink_program_name);
790 *next_domain = domain ? domain : old_domain;