2 * security/tomoyo/domain.c
4 * Domain transition functions for TOMOYO.
6 * Copyright (C) 2005-2010 NTT DATA CORPORATION
10 #include <linux/binfmts.h>
11 #include <linux/slab.h>
13 /* Variables definitions.*/
15 /* The initial domain. */
16 struct tomoyo_domain_info tomoyo_kernel_domain
;
19 * tomoyo_domain_list is used for holding list of domains.
20 * The ->acl_info_list of "struct tomoyo_domain_info" is used for holding
21 * permissions (e.g. "allow_read /lib/libc-2.5.so") given to each domain.
23 * An entry is added by
25 * # ( echo "<kernel>"; echo "allow_execute /sbin/init" ) > \
26 * /sys/kernel/security/tomoyo/domain_policy
30 * # ( echo "<kernel>"; echo "delete allow_execute /sbin/init" ) > \
31 * /sys/kernel/security/tomoyo/domain_policy
33 * and all entries are retrieved by
35 * # cat /sys/kernel/security/tomoyo/domain_policy
37 * A domain is added by
39 * # echo "<kernel>" > /sys/kernel/security/tomoyo/domain_policy
43 * # echo "delete <kernel>" > /sys/kernel/security/tomoyo/domain_policy
45 * and all domains are retrieved by
47 * # grep '^<kernel>' /sys/kernel/security/tomoyo/domain_policy
49 * Normally, a domainname is monotonically getting longer because a domainname
50 * which the process will belong to if an execve() operation succeeds is
51 * defined as a concatenation of "current domainname" + "pathname passed to
53 * See tomoyo_domain_initializer_list and tomoyo_domain_keeper_list for
56 LIST_HEAD(tomoyo_domain_list
);
59 * tomoyo_get_last_name - Get last component of a domainname.
61 * @domain: Pointer to "struct tomoyo_domain_info".
63 * Returns the last component of the domainname.
65 const char *tomoyo_get_last_name(const struct tomoyo_domain_info
*domain
)
67 const char *cp0
= domain
->domainname
->name
;
68 const char *cp1
= strrchr(cp0
, ' ');
76 * tomoyo_domain_initializer_list is used for holding list of programs which
77 * triggers reinitialization of domainname. Normally, a domainname is
78 * monotonically getting longer. But sometimes, we restart daemon programs.
79 * It would be convenient for us that "a daemon started upon system boot" and
80 * "the daemon restarted from console" belong to the same domain. Thus, TOMOYO
81 * provides a way to shorten domainnames.
83 * An entry is added by
85 * # echo 'initialize_domain /usr/sbin/httpd' > \
86 * /sys/kernel/security/tomoyo/exception_policy
90 * # echo 'delete initialize_domain /usr/sbin/httpd' > \
91 * /sys/kernel/security/tomoyo/exception_policy
93 * and all entries are retrieved by
95 * # grep ^initialize_domain /sys/kernel/security/tomoyo/exception_policy
97 * In the example above, /usr/sbin/httpd will belong to
98 * "<kernel> /usr/sbin/httpd" domain.
100 * You may specify a domainname using "from" keyword.
101 * "initialize_domain /usr/sbin/httpd from <kernel> /etc/rc.d/init.d/httpd"
102 * will cause "/usr/sbin/httpd" executed from "<kernel> /etc/rc.d/init.d/httpd"
103 * domain to belong to "<kernel> /usr/sbin/httpd" domain.
105 * You may add "no_" prefix to "initialize_domain".
106 * "initialize_domain /usr/sbin/httpd" and
107 * "no_initialize_domain /usr/sbin/httpd from <kernel> /etc/rc.d/init.d/httpd"
108 * will cause "/usr/sbin/httpd" to belong to "<kernel> /usr/sbin/httpd" domain
109 * unless executed from "<kernel> /etc/rc.d/init.d/httpd" domain.
111 LIST_HEAD(tomoyo_domain_initializer_list
);
114 * tomoyo_update_domain_initializer_entry - Update "struct tomoyo_domain_initializer_entry" list.
116 * @domainname: The name of domain. May be NULL.
117 * @program: The name of program.
118 * @is_not: True if it is "no_initialize_domain" entry.
119 * @is_delete: True if it is a delete request.
121 * Returns 0 on success, negative value otherwise.
123 * Caller holds tomoyo_read_lock().
125 static int tomoyo_update_domain_initializer_entry(const char *domainname
,
128 const bool is_delete
)
130 struct tomoyo_domain_initializer_entry
*ptr
;
131 struct tomoyo_domain_initializer_entry e
= { .is_not
= is_not
};
132 int error
= is_delete
? -ENOENT
: -ENOMEM
;
134 if (!tomoyo_is_correct_path(program
, 1, -1, -1))
135 return -EINVAL
; /* No patterns allowed. */
137 if (!tomoyo_is_domain_def(domainname
) &&
138 tomoyo_is_correct_path(domainname
, 1, -1, -1))
139 e
.is_last_name
= true;
140 else if (!tomoyo_is_correct_domain(domainname
))
142 e
.domainname
= tomoyo_get_name(domainname
);
146 e
.program
= tomoyo_get_name(program
);
149 if (mutex_lock_interruptible(&tomoyo_policy_lock
))
151 list_for_each_entry_rcu(ptr
, &tomoyo_domain_initializer_list
, list
) {
152 if (!tomoyo_is_same_domain_initializer_entry(ptr
, &e
))
154 ptr
->is_deleted
= is_delete
;
158 if (!is_delete
&& error
) {
159 struct tomoyo_domain_initializer_entry
*entry
=
160 tomoyo_commit_ok(&e
, sizeof(e
));
162 list_add_tail_rcu(&entry
->list
,
163 &tomoyo_domain_initializer_list
);
167 mutex_unlock(&tomoyo_policy_lock
);
169 tomoyo_put_name(e
.domainname
);
170 tomoyo_put_name(e
.program
);
175 * tomoyo_read_domain_initializer_policy - Read "struct tomoyo_domain_initializer_entry" list.
177 * @head: Pointer to "struct tomoyo_io_buffer".
179 * Returns true on success, false otherwise.
181 * Caller holds tomoyo_read_lock().
183 bool tomoyo_read_domain_initializer_policy(struct tomoyo_io_buffer
*head
)
185 struct list_head
*pos
;
188 list_for_each_cookie(pos
, head
->read_var2
,
189 &tomoyo_domain_initializer_list
) {
191 const char *from
= "";
192 const char *domain
= "";
193 struct tomoyo_domain_initializer_entry
*ptr
;
194 ptr
= list_entry(pos
, struct tomoyo_domain_initializer_entry
,
198 no
= ptr
->is_not
? "no_" : "";
199 if (ptr
->domainname
) {
201 domain
= ptr
->domainname
->name
;
203 done
= tomoyo_io_printf(head
,
204 "%s" TOMOYO_KEYWORD_INITIALIZE_DOMAIN
205 "%s%s%s\n", no
, ptr
->program
->name
,
214 * tomoyo_write_domain_initializer_policy - Write "struct tomoyo_domain_initializer_entry" list.
216 * @data: String to parse.
217 * @is_not: True if it is "no_initialize_domain" entry.
218 * @is_delete: True if it is a delete request.
220 * Returns 0 on success, negative value otherwise.
222 * Caller holds tomoyo_read_lock().
224 int tomoyo_write_domain_initializer_policy(char *data
, const bool is_not
,
225 const bool is_delete
)
227 char *cp
= strstr(data
, " from ");
231 return tomoyo_update_domain_initializer_entry(cp
+ 6, data
,
235 return tomoyo_update_domain_initializer_entry(NULL
, data
, is_not
,
240 * tomoyo_is_domain_initializer - Check whether the given program causes domainname reinitialization.
242 * @domainname: The name of domain.
243 * @program: The name of program.
244 * @last_name: The last component of @domainname.
246 * Returns true if executing @program reinitializes domain transition,
249 * Caller holds tomoyo_read_lock().
251 static bool tomoyo_is_domain_initializer(const struct tomoyo_path_info
*
253 const struct tomoyo_path_info
*program
,
254 const struct tomoyo_path_info
*
257 struct tomoyo_domain_initializer_entry
*ptr
;
260 list_for_each_entry_rcu(ptr
, &tomoyo_domain_initializer_list
, list
) {
263 if (ptr
->domainname
) {
264 if (!ptr
->is_last_name
) {
265 if (ptr
->domainname
!= domainname
)
268 if (tomoyo_pathcmp(ptr
->domainname
, last_name
))
272 if (tomoyo_pathcmp(ptr
->program
, program
))
284 * tomoyo_domain_keeper_list is used for holding list of domainnames which
285 * suppresses domain transition. Normally, a domainname is monotonically
286 * getting longer. But sometimes, we want to suppress domain transition.
287 * It would be convenient for us that programs executed from a login session
288 * belong to the same domain. Thus, TOMOYO provides a way to suppress domain
291 * An entry is added by
293 * # echo 'keep_domain <kernel> /usr/sbin/sshd /bin/bash' > \
294 * /sys/kernel/security/tomoyo/exception_policy
298 * # echo 'delete keep_domain <kernel> /usr/sbin/sshd /bin/bash' > \
299 * /sys/kernel/security/tomoyo/exception_policy
301 * and all entries are retrieved by
303 * # grep ^keep_domain /sys/kernel/security/tomoyo/exception_policy
305 * In the example above, any process which belongs to
306 * "<kernel> /usr/sbin/sshd /bin/bash" domain will remain in that domain,
307 * unless explicitly specified by "initialize_domain" or "no_keep_domain".
309 * You may specify a program using "from" keyword.
310 * "keep_domain /bin/pwd from <kernel> /usr/sbin/sshd /bin/bash"
311 * will cause "/bin/pwd" executed from "<kernel> /usr/sbin/sshd /bin/bash"
312 * domain to remain in "<kernel> /usr/sbin/sshd /bin/bash" domain.
314 * You may add "no_" prefix to "keep_domain".
315 * "keep_domain <kernel> /usr/sbin/sshd /bin/bash" and
316 * "no_keep_domain /usr/bin/passwd from <kernel> /usr/sbin/sshd /bin/bash" will
317 * cause "/usr/bin/passwd" to belong to
318 * "<kernel> /usr/sbin/sshd /bin/bash /usr/bin/passwd" domain, unless
319 * explicitly specified by "initialize_domain".
321 LIST_HEAD(tomoyo_domain_keeper_list
);
324 * tomoyo_update_domain_keeper_entry - Update "struct tomoyo_domain_keeper_entry" list.
326 * @domainname: The name of domain.
327 * @program: The name of program. May be NULL.
328 * @is_not: True if it is "no_keep_domain" entry.
329 * @is_delete: True if it is a delete request.
331 * Returns 0 on success, negative value otherwise.
333 * Caller holds tomoyo_read_lock().
335 static int tomoyo_update_domain_keeper_entry(const char *domainname
,
338 const bool is_delete
)
340 struct tomoyo_domain_keeper_entry
*ptr
;
341 struct tomoyo_domain_keeper_entry e
= { .is_not
= is_not
};
342 int error
= is_delete
? -ENOENT
: -ENOMEM
;
344 if (!tomoyo_is_domain_def(domainname
) &&
345 tomoyo_is_correct_path(domainname
, 1, -1, -1))
346 e
.is_last_name
= true;
347 else if (!tomoyo_is_correct_domain(domainname
))
350 if (!tomoyo_is_correct_path(program
, 1, -1, -1))
352 e
.program
= tomoyo_get_name(program
);
356 e
.domainname
= tomoyo_get_name(domainname
);
359 if (mutex_lock_interruptible(&tomoyo_policy_lock
))
361 list_for_each_entry_rcu(ptr
, &tomoyo_domain_keeper_list
, list
) {
362 if (!tomoyo_is_same_domain_keeper_entry(ptr
, &e
))
364 ptr
->is_deleted
= is_delete
;
368 if (!is_delete
&& error
) {
369 struct tomoyo_domain_keeper_entry
*entry
=
370 tomoyo_commit_ok(&e
, sizeof(e
));
372 list_add_tail_rcu(&entry
->list
,
373 &tomoyo_domain_keeper_list
);
377 mutex_unlock(&tomoyo_policy_lock
);
379 tomoyo_put_name(e
.domainname
);
380 tomoyo_put_name(e
.program
);
385 * tomoyo_write_domain_keeper_policy - Write "struct tomoyo_domain_keeper_entry" list.
387 * @data: String to parse.
388 * @is_not: True if it is "no_keep_domain" entry.
389 * @is_delete: True if it is a delete request.
391 * Caller holds tomoyo_read_lock().
393 int tomoyo_write_domain_keeper_policy(char *data
, const bool is_not
,
394 const bool is_delete
)
396 char *cp
= strstr(data
, " from ");
400 return tomoyo_update_domain_keeper_entry(cp
+ 6, data
, is_not
,
403 return tomoyo_update_domain_keeper_entry(data
, NULL
, is_not
, is_delete
);
407 * tomoyo_read_domain_keeper_policy - Read "struct tomoyo_domain_keeper_entry" list.
409 * @head: Pointer to "struct tomoyo_io_buffer".
411 * Returns true on success, false otherwise.
413 * Caller holds tomoyo_read_lock().
415 bool tomoyo_read_domain_keeper_policy(struct tomoyo_io_buffer
*head
)
417 struct list_head
*pos
;
420 list_for_each_cookie(pos
, head
->read_var2
,
421 &tomoyo_domain_keeper_list
) {
422 struct tomoyo_domain_keeper_entry
*ptr
;
424 const char *from
= "";
425 const char *program
= "";
427 ptr
= list_entry(pos
, struct tomoyo_domain_keeper_entry
, list
);
430 no
= ptr
->is_not
? "no_" : "";
433 program
= ptr
->program
->name
;
435 done
= tomoyo_io_printf(head
,
436 "%s" TOMOYO_KEYWORD_KEEP_DOMAIN
437 "%s%s%s\n", no
, program
, from
,
438 ptr
->domainname
->name
);
446 * tomoyo_is_domain_keeper - Check whether the given program causes domain transition suppression.
448 * @domainname: The name of domain.
449 * @program: The name of program.
450 * @last_name: The last component of @domainname.
452 * Returns true if executing @program supresses domain transition,
455 * Caller holds tomoyo_read_lock().
457 static bool tomoyo_is_domain_keeper(const struct tomoyo_path_info
*domainname
,
458 const struct tomoyo_path_info
*program
,
459 const struct tomoyo_path_info
*last_name
)
461 struct tomoyo_domain_keeper_entry
*ptr
;
464 list_for_each_entry_rcu(ptr
, &tomoyo_domain_keeper_list
, list
) {
467 if (!ptr
->is_last_name
) {
468 if (ptr
->domainname
!= domainname
)
471 if (tomoyo_pathcmp(ptr
->domainname
, last_name
))
474 if (ptr
->program
&& tomoyo_pathcmp(ptr
->program
, program
))
486 * tomoyo_alias_list is used for holding list of symlink's pathnames which are
487 * allowed to be passed to an execve() request. Normally, the domainname which
488 * the current process will belong to after execve() succeeds is calculated
489 * using dereferenced pathnames. But some programs behave differently depending
490 * on the name passed to argv[0]. For busybox, calculating domainname using
491 * dereferenced pathnames will cause all programs in the busybox to belong to
492 * the same domain. Thus, TOMOYO provides a way to allow use of symlink's
493 * pathname for checking execve()'s permission and calculating domainname which
494 * the current process will belong to after execve() succeeds.
496 * An entry is added by
498 * # echo 'alias /bin/busybox /bin/cat' > \
499 * /sys/kernel/security/tomoyo/exception_policy
503 * # echo 'delete alias /bin/busybox /bin/cat' > \
504 * /sys/kernel/security/tomoyo/exception_policy
506 * and all entries are retrieved by
508 * # grep ^alias /sys/kernel/security/tomoyo/exception_policy
510 * In the example above, if /bin/cat is a symlink to /bin/busybox and execution
511 * of /bin/cat is requested, permission is checked for /bin/cat rather than
512 * /bin/busybox and domainname which the current process will belong to after
513 * execve() succeeds is calculated using /bin/cat rather than /bin/busybox .
515 LIST_HEAD(tomoyo_alias_list
);
518 * tomoyo_update_alias_entry - Update "struct tomoyo_alias_entry" list.
520 * @original_name: The original program's real name.
521 * @aliased_name: The symbolic program's symbolic link's name.
522 * @is_delete: True if it is a delete request.
524 * Returns 0 on success, negative value otherwise.
526 * Caller holds tomoyo_read_lock().
528 static int tomoyo_update_alias_entry(const char *original_name
,
529 const char *aliased_name
,
530 const bool is_delete
)
532 struct tomoyo_alias_entry
*ptr
;
533 struct tomoyo_alias_entry e
= { };
534 int error
= is_delete
? -ENOENT
: -ENOMEM
;
536 if (!tomoyo_is_correct_path(original_name
, 1, -1, -1) ||
537 !tomoyo_is_correct_path(aliased_name
, 1, -1, -1))
538 return -EINVAL
; /* No patterns allowed. */
539 e
.original_name
= tomoyo_get_name(original_name
);
540 e
.aliased_name
= tomoyo_get_name(aliased_name
);
541 if (!e
.original_name
|| !e
.aliased_name
)
543 if (mutex_lock_interruptible(&tomoyo_policy_lock
))
545 list_for_each_entry_rcu(ptr
, &tomoyo_alias_list
, list
) {
546 if (!tomoyo_is_same_alias_entry(ptr
, &e
))
548 ptr
->is_deleted
= is_delete
;
552 if (!is_delete
&& error
) {
553 struct tomoyo_alias_entry
*entry
=
554 tomoyo_commit_ok(&e
, sizeof(e
));
556 list_add_tail_rcu(&entry
->list
, &tomoyo_alias_list
);
560 mutex_unlock(&tomoyo_policy_lock
);
562 tomoyo_put_name(e
.original_name
);
563 tomoyo_put_name(e
.aliased_name
);
568 * tomoyo_read_alias_policy - Read "struct tomoyo_alias_entry" list.
570 * @head: Pointer to "struct tomoyo_io_buffer".
572 * Returns true on success, false otherwise.
574 * Caller holds tomoyo_read_lock().
576 bool tomoyo_read_alias_policy(struct tomoyo_io_buffer
*head
)
578 struct list_head
*pos
;
581 list_for_each_cookie(pos
, head
->read_var2
, &tomoyo_alias_list
) {
582 struct tomoyo_alias_entry
*ptr
;
584 ptr
= list_entry(pos
, struct tomoyo_alias_entry
, list
);
587 done
= tomoyo_io_printf(head
, TOMOYO_KEYWORD_ALIAS
"%s %s\n",
588 ptr
->original_name
->name
,
589 ptr
->aliased_name
->name
);
597 * tomoyo_write_alias_policy - Write "struct tomoyo_alias_entry" list.
599 * @data: String to parse.
600 * @is_delete: True if it is a delete request.
602 * Returns 0 on success, negative value otherwise.
604 * Caller holds tomoyo_read_lock().
606 int tomoyo_write_alias_policy(char *data
, const bool is_delete
)
608 char *cp
= strchr(data
, ' ');
613 return tomoyo_update_alias_entry(data
, cp
, is_delete
);
617 * tomoyo_find_or_assign_new_domain - Create a domain.
619 * @domainname: The name of domain.
620 * @profile: Profile number to assign if the domain was newly created.
622 * Returns pointer to "struct tomoyo_domain_info" on success, NULL otherwise.
624 * Caller holds tomoyo_read_lock().
626 struct tomoyo_domain_info
*tomoyo_find_or_assign_new_domain(const char *
630 struct tomoyo_domain_info
*entry
;
631 struct tomoyo_domain_info
*domain
= NULL
;
632 const struct tomoyo_path_info
*saved_domainname
;
635 if (!tomoyo_is_correct_domain(domainname
))
637 saved_domainname
= tomoyo_get_name(domainname
);
638 if (!saved_domainname
)
640 entry
= kzalloc(sizeof(*entry
), GFP_NOFS
);
641 if (mutex_lock_interruptible(&tomoyo_policy_lock
))
643 list_for_each_entry_rcu(domain
, &tomoyo_domain_list
, list
) {
644 if (domain
->is_deleted
||
645 tomoyo_pathcmp(saved_domainname
, domain
->domainname
))
650 if (!found
&& tomoyo_memory_ok(entry
)) {
651 INIT_LIST_HEAD(&entry
->acl_info_list
);
652 entry
->domainname
= saved_domainname
;
653 saved_domainname
= NULL
;
654 entry
->profile
= profile
;
655 list_add_tail_rcu(&entry
->list
, &tomoyo_domain_list
);
660 mutex_unlock(&tomoyo_policy_lock
);
662 tomoyo_put_name(saved_domainname
);
664 return found
? domain
: NULL
;
668 * tomoyo_find_next_domain - Find a domain.
670 * @bprm: Pointer to "struct linux_binprm".
672 * Returns 0 on success, negative value otherwise.
674 * Caller holds tomoyo_read_lock().
676 int tomoyo_find_next_domain(struct linux_binprm
*bprm
)
678 struct tomoyo_request_info r
;
679 char *tmp
= kzalloc(TOMOYO_EXEC_TMPSIZE
, GFP_NOFS
);
680 struct tomoyo_domain_info
*old_domain
= tomoyo_domain();
681 struct tomoyo_domain_info
*domain
= NULL
;
682 const char *old_domain_name
= old_domain
->domainname
->name
;
683 const char *original_name
= bprm
->filename
;
684 const u8 mode
= tomoyo_check_flags(old_domain
, TOMOYO_MAC_FOR_FILE
);
685 const bool is_enforce
= (mode
== TOMOYO_CONFIG_ENFORCING
);
686 int retval
= -ENOMEM
;
687 bool need_kfree
= false;
688 struct tomoyo_path_info rn
= { }; /* real name */
689 struct tomoyo_path_info sn
= { }; /* symlink name */
690 struct tomoyo_path_info ln
; /* last name */
692 ln
.name
= tomoyo_get_last_name(old_domain
);
693 tomoyo_fill_path_info(&ln
);
694 tomoyo_init_request_info(&r
, NULL
);
703 /* Get tomoyo_realpath of program. */
705 rn
.name
= tomoyo_realpath(original_name
);
708 tomoyo_fill_path_info(&rn
);
711 /* Get tomoyo_realpath of symbolic link. */
712 sn
.name
= tomoyo_realpath_nofollow(original_name
);
715 tomoyo_fill_path_info(&sn
);
717 /* Check 'alias' directive. */
718 if (tomoyo_pathcmp(&rn
, &sn
)) {
719 struct tomoyo_alias_entry
*ptr
;
720 /* Is this program allowed to be called via symbolic links? */
721 list_for_each_entry_rcu(ptr
, &tomoyo_alias_list
, list
) {
722 if (ptr
->is_deleted
||
723 tomoyo_pathcmp(&rn
, ptr
->original_name
) ||
724 tomoyo_pathcmp(&sn
, ptr
->aliased_name
))
728 /* This is OK because it is read only. */
729 rn
= *ptr
->aliased_name
;
734 /* Check execute permission. */
735 retval
= tomoyo_check_exec_perm(old_domain
, &rn
);
736 if (retval
== TOMOYO_RETRY_REQUEST
)
741 if (tomoyo_is_domain_initializer(old_domain
->domainname
, &rn
, &ln
)) {
742 /* Transit to the child of tomoyo_kernel_domain domain. */
743 snprintf(tmp
, TOMOYO_EXEC_TMPSIZE
- 1,
744 TOMOYO_ROOT_NAME
" " "%s", rn
.name
);
745 } else if (old_domain
== &tomoyo_kernel_domain
&&
746 !tomoyo_policy_loaded
) {
748 * Needn't to transit from kernel domain before starting
749 * /sbin/init. But transit from kernel domain if executing
750 * initializers because they might start before /sbin/init.
753 } else if (tomoyo_is_domain_keeper(old_domain
->domainname
, &rn
, &ln
)) {
754 /* Keep current domain. */
757 /* Normal domain transition. */
758 snprintf(tmp
, TOMOYO_EXEC_TMPSIZE
- 1,
759 "%s %s", old_domain_name
, rn
.name
);
761 if (domain
|| strlen(tmp
) >= TOMOYO_EXEC_TMPSIZE
- 10)
763 domain
= tomoyo_find_domain(tmp
);
767 int error
= tomoyo_supervisor(&r
, "# wants to create domain\n"
769 if (error
== TOMOYO_RETRY_REQUEST
)
774 domain
= tomoyo_find_or_assign_new_domain(tmp
, old_domain
->profile
);
778 printk(KERN_WARNING
"TOMOYO-ERROR: Domain '%s' not defined.\n", tmp
);
782 old_domain
->transition_failed
= true;
786 /* Update reference count on "struct tomoyo_domain_info". */
787 atomic_inc(&domain
->users
);
788 bprm
->cred
->security
= domain
;