policy_module(icecream,0.0.42)

########################################
#
# Declarations
#

# the compiler node daemon
type iceccd_t;
type iceccd_exec_t;
init_daemon_domain(iceccd_t, iceccd_exec_t)

type iceccd_log_t;
logging_log_file(iceccd_log_t)

type iceccd_tmp_t;
files_tmp_file(iceccd_tmp_t)

type iceccd_var_run_t;
files_pid_file(iceccd_var_run_t)

# the working area
type iceccd_cache_t;
files_type(iceccd_cache_t)

# icecc-create-env script makes a tarball of the local compiler and its
# dependencies for other nodes to use
type iceccd_createenv_t;
type iceccd_createenv_exec_t;
domain_type(iceccd_createenv_t)
domain_entry_file(iceccd_createenv_t, iceccd_createenv_exec_t)
role system_r types iceccd_createenv_t;

# foreign compilers
type iceccd_untrusted_t;
domain_type(iceccd_untrusted_t);
domain_entry_file(iceccd_untrusted_t, iceccd_cache_t)
role system_r types iceccd_untrusted_t;

# the scheduler
type icecc_scheduler_t;
type icecc_scheduler_exec_t;
init_daemon_domain(icecc_scheduler_t, icecc_scheduler_exec_t)

type iceccd_port_t;
type icecc_scheduler_port_t;
corenet_port(iceccd_port_t);
corenet_port(icecc_scheduler_port_t);

########################################
#
# Icecream policy
#

allow iceccd_t self:process { signal_perms setsched setrlimit };
allow iceccd_t self:netlink_route_socket r_netlink_socket_perms;
allow iceccd_t self:tcp_socket create_stream_socket_perms;
allow iceccd_t self:udp_socket create_socket_perms;
allow iceccd_t self:fifo_file rw_fifo_file_perms;
allow iceccd_t self:capability { chown dac_override fsetid kill setgid setuid sys_chroot };
allow iceccd_t iceccd_untrusted_t:process { siginh rlimitinh noatsecure signal };

files_read_etc_files(iceccd_t)
libs_use_ld_so(iceccd_t)
libs_use_shared_libs(iceccd_t)
miscfiles_read_localization(iceccd_t)

fs_getattr_all_fs(iceccd_t)
kernel_read_system_state(iceccd_t)
sysnet_read_config(iceccd_t)

corecmd_exec_bin(iceccd_t)
corecmd_read_bin_symlinks(iceccd_t)

files_getattr_tmp_dirs(iceccd_t)
files_search_tmp(iceccd_t)

corenet_all_recvfrom_unlabeled(iceccd_t)
corenet_all_recvfrom_netlabel(iceccd_t)
corenet_tcp_sendrecv_generic_if(iceccd_t)
corenet_udp_sendrecv_generic_if(iceccd_t)
corenet_tcp_sendrecv_generic_node(iceccd_t)
corenet_udp_sendrecv_generic_node(iceccd_t)
corenet_tcp_sendrecv_all_ports(iceccd_t)
corenet_udp_sendrecv_all_ports(iceccd_t)
corenet_tcp_bind_generic_node(iceccd_t)
allow iceccd_t iceccd_port_t:tcp_socket { name_bind };
allow iceccd_t icecc_scheduler_port_t:tcp_socket { name_connect };

domtrans_pattern(iceccd_t, iceccd_createenv_exec_t, iceccd_createenv_t)
domtrans_pattern(iceccd_t, iceccd_cache_t, iceccd_untrusted_t)

manage_files_pattern(iceccd_t, iceccd_log_t, iceccd_log_t)
logging_log_filetrans(iceccd_t, iceccd_log_t, file)

manage_files_pattern(iceccd_t, iceccd_var_run_t, iceccd_var_run_t)
files_pid_filetrans(iceccd_t, iceccd_var_run_t, file)

manage_dirs_pattern(iceccd_t, iceccd_cache_t, iceccd_cache_t)
manage_files_pattern(iceccd_t, iceccd_cache_t, iceccd_cache_t)

manage_dirs_pattern(iceccd_t, iceccd_tmp_t, iceccd_tmp_t)
manage_files_pattern(iceccd_t, iceccd_tmp_t, iceccd_tmp_t)
files_tmp_filetrans(iceccd_t, iceccd_tmp_t, file)


allow iceccd_createenv_t iceccd_log_t:file { append };
allow iceccd_createenv_t self:fifo_file rw_fifo_file_perms;
# icecc-create-env looks for executable files to strip them. It does not
# really execute them, but the -x check would trigger a denial. Do not allow
# this, typically the binaries are already stripped anyway. Just silence it.
dontaudit iceccd_createenv_t iceccd_tmp_t:file { execute };

allow iceccd_untrusted_t self:fifo_file rw_fifo_file_perms;
allow iceccd_untrusted_t self:process signal_perms;
allow iceccd_untrusted_t iceccd_t:unix_stream_socket rw_sock_file_perms;
manage_files_pattern(iceccd_untrusted_t, iceccd_cache_t, iceccd_cache_t)
allow iceccd_untrusted_t iceccd_cache_t:file { execute_no_trans };

files_read_etc_files(iceccd_createenv_t)
libs_use_ld_so(iceccd_createenv_t)
libs_use_shared_libs(iceccd_createenv_t)
miscfiles_read_localization(iceccd_createenv_t)

manage_dirs_pattern(iceccd_createenv_t, iceccd_cache_t, iceccd_cache_t)
manage_files_pattern(iceccd_createenv_t, iceccd_cache_t, iceccd_cache_t)

files_read_usr_files(iceccd_createenv_t)
libs_exec_ld_so(iceccd_createenv_t)
libs_exec_lib_files(iceccd_createenv_t)
libs_domtrans_ldconfig(iceccd_createenv_t)
corecmd_exec_bin(iceccd_createenv_t)
corecmd_exec_shell(iceccd_createenv_t)
dev_read_urand(iceccd_createenv_t)
kernel_read_system_state(iceccd_createenv_t)
# silence file(1) looking for /root/.magic
userdom_dontaudit_search_admin_dir(iceccd_createenv_t)

manage_dirs_pattern(iceccd_createenv_t, iceccd_tmp_t, iceccd_tmp_t)
manage_files_pattern(iceccd_createenv_t, iceccd_tmp_t, iceccd_tmp_t)
files_tmp_filetrans(iceccd_createenv_t, iceccd_tmp_t, file)
files_tmp_filetrans(iceccd_createenv_t, iceccd_tmp_t, dir)

optional_policy(`
	nscd_socket_use(iceccd_createenv_t)
')

# Some rules that can probably go away when iceccd is fixed properly:
#
# XXX: icecc-create-env does not really need to talk to the open UDP socket
# leaked from its parent.
dontaudit iceccd_createenv_t iceccd_t:udp_socket { read write };
# XXX: iceccd could be modified to avoid the shell completely
corecmd_exec_shell(iceccd_t)
# XXX: fix iceccd to only nuke the contents of /var/cache/icecream,
# not the directory itself.
files_var_filetrans(iceccd_t, iceccd_cache_t, dir)


allow icecc_scheduler_t self:tcp_socket create_stream_socket_perms;
allow icecc_scheduler_t self:udp_socket create_socket_perms;

files_read_etc_files(icecc_scheduler_t)
libs_use_ld_so(icecc_scheduler_t)
libs_use_shared_libs(icecc_scheduler_t)
miscfiles_read_localization(icecc_scheduler_t)

corenet_all_recvfrom_unlabeled(icecc_scheduler_t)
corenet_all_recvfrom_netlabel(icecc_scheduler_t)
corenet_tcp_sendrecv_generic_if(icecc_scheduler_t)
corenet_udp_sendrecv_generic_if(icecc_scheduler_t)
corenet_tcp_sendrecv_generic_node(icecc_scheduler_t)
corenet_udp_sendrecv_generic_node(icecc_scheduler_t)
corenet_tcp_sendrecv_all_ports(icecc_scheduler_t)
corenet_udp_sendrecv_all_ports(icecc_scheduler_t)
corenet_tcp_bind_generic_node(icecc_scheduler_t)
corenet_udp_bind_generic_node(icecc_scheduler_t)
allow icecc_scheduler_t icecc_scheduler_port_t:tcp_socket { name_bind };
allow icecc_scheduler_t icecc_scheduler_port_t:udp_socket { name_bind };