policy files
speedmgmt is for the Alcatel USB ADSL device management program./usr/sbin/speedmgmt system_u:object_r:speedmgmt_exec_t
dictd is for the dictionary daemon
/var/lib/dictd(|/.*) system_u:object_r:var_lib_dictd_t /etc/dictd.conf system_u:object_r:etc_dictd_t /usr/sbin/dictd system_u:object_r:dictd_exec_t
radius is generically for radius servers (needs much more work but it's a good starting point for anyone else who wants to work on such things)
/etc/raddb(|/.*) system_u:object_r:etc_radiusd_t/usr/sbin/radiusd system_u:object_r:radiusd_exec_t
/var/log/radiusd-freeradius(|/.*) system_u:object_r:var_log_radiusd_t
cups is for the Common Unix Printing System (needs more work)
/etc/cups(|/.*) system_u:object_r:etc_cupsd_t /etc/printcap.cups system_u:object_r:etc_cupsd_t /usr/lib/cups/backend system_u:object_r:cupsd_exec_t /usr/sbin/cupsd system_u:object_r:cupsd_exec_t /var/spool/cups(|/.*) system_u:object_r:cupsd_spool_t /var/log/cups(|/.*) system_u:object_r:var_log_cups_t
usbmodules is for a helper program that's used for determining the correct USB device driver to load for a device./usr/sbin/usbmodules system_u:object_r:usbmodules_exec_t
dpkg is for Debian package installation (people working on RPM may want to check it out)
/var/lib/dpkg(|/.*) system_u:object_r:var_lib_dpkg_t /var/lib/dpkg/(|meth)lock system_u:object_r:dpkg_lock_t /var/lib/apt(|/.*) system_u:object_r:var_lib_apt_t /var/cache/apt(|/.*) system_u:object_r:var_cache_apt_t /etc/apt(|/.*) system_u:object_r:etc_apt_t /usr/bin/dpkg system_u:object_r:dpkg_exec_t /usr/bin/dselect system_u:object_r:dpkg_exec_t /usr/bin/apt-get system_u:object_r:apt_exec_t /usr/bin/apt-cache system_u:object_r:apt_exec_t /usr/bin/apt-config system_u:object_r:apt_exec_t /usr/lib/apt/methods/.* system_u:object_r:apt_exec_t /usr/lib/dpkg/methods/.* system_u:object_r:dpkg_exec_t /usr/sbin/se_dpkg system_u:object_r:run_deb_exec_t /usr/sbin/dpkg-preconfigure system_u:object_r:dpkg_exec_t
Here's a patch for syslog policy to better support devfs:
policy/domains/program/syslogd.te +1 -1
@@ -34,7 +34,7 @@ allow syslogd_t var_log_t:file rw_file_perms; # Create and bind to /dev/log. -file_type_auto_trans(syslogd_t, device_t, devlog_t) +file_type_auto_trans(syslogd_t, { device_t devfs_t }, devlog_t) allow syslogd_t devlog_t:unix_stream_socket name_bind; allow syslogd_t devlog_t:unix_dgram_socket name_bind;
sysstat is for sar type programs
/usr/lib/sysstat/sadc system_u:object_r:sysstat_exec_t /usr/lib/atsar/atsadc system_u:object_r:sysstat_exec_t /var/log/sysstat(|/.*) system_u:object_r:var_log_sysstat_t /var/log/atsar(|/.*) system_u:object_r:var_log_sysstat_t
radvd is for the IPv6 routing advice daemon/etc/radvd.conf system_u:object_r:etc_radvd_t/usr/sbin/radvd system_u:object_r:radvd_exec_t
sshd policy needs the sys_resource capability in the Debian setup and I think it's reasonable to allow it in the default setup.
courier is for the courier POP, IMAP, and webmail services. It's not nearly finished, but will be a lot of help to people who want to do further work (and it's quite functional for basic use).
/etc/courier(|/.*) system_u:object_r:etc_courier_t
/usr/lib/courier(|/.*) system_u:object_r:etc_courier_t/usr/lib/courier/sqwebmail/cleancache.pl system_u:object_r:sqwebmail_cron_exec_t/usr/lib/courier/pop3d system_u:object_r:courier_pop_exec_t
/usr/lib/courier/imapd system_u:object_r:courier_pop_exec_t /usr/lib/courier/authlib/.* system_u:object_r:courier_authdaemon_exec_t /usr/lib/courier/courier/.* system_u:object_r:courier_exec_t /usr/lib/courier/courier/courierpop.* system_u:object_r:courier_pop_exec_t /usr/lib/courier/courier/courierpop3.* system_u:object_r:courier_pop_exec_t /usr/lib/courier/courier/imaplogin system_u:object_r:courier_pop_exec_t /usr/lib/courier/courier/pcpd system_u:object_r:courier_pcp_exec_t /usr/sbin/couriertcpd system_u:object_r:courier_tcpd_exec_t /usr/sbin/courierlogger system_u:object_r:courier_exec_t /var/run/courier.* system_u:object_r:courier_var_run_t
The above is about 30% of the policy changes I've made as compared to the sample policy shipped on the NSA site. It's difficult for me to send out anything else in a mergable form (sending a tar file of my policy directory probably won't be very helpful) as the rest is either too experimental, or has dependencies on some of the things in this message.
Steve, could you please make available a patch between the released policy and the policy that is in your internal CVS for the next public release so I can follow the next development and provide suitable additions and patches?
Signature · 4 lines
If you send email to me or to a mailing list that I use which has >4 lines of legalistic junk at the end then you are specifically authorizing me to do whatever I wish with the message and all other messages from your domain, by posting the message you agree that your long legalistic sig is void.
#
# Author: Russell Coker <[email protected]>
#
#################################
#
# Rules for the speedmgmt_t domain.
#
# speedmgmt_exec_t is the type of the speedmgmt executable. # type speedmgmt_t, domain, privlog; type speedmgmt_exec_t, file_type, sysadmfile, exec_type; type speedmgmt_tmp_t, file_type, sysadmfile, tmpfile;
role system_r types speedmgmt_t;
allow speedmgmt_t init_t:process sigchld; domain_auto_trans(initrc_t, speedmgmt_exec_t, speedmgmt_t) file_type_auto_trans(speedmgmt_t, tmp_t, speedmgmt_tmp_t) uses_shlib(speedmgmt_t)
# for accessing USB allow speedmgmt_t proc_t:dir r_dir_perms; allow speedmgmt_t usbdevfs_device_t:file rw_file_perms; allow speedmgmt_t usbdevfs_t:dir r_dir_perms;
allow speedmgmt_t usr_t:file r_file_perms;
allow speedmgmt_t self:unix_dgram_socket create_socket_perms;
# allow time allow speedmgmt_t etc_t:dir r_dir_perms; allow speedmgmt_t etc_t:lnk_file r_file_perms;
#
# Authors: Russell Coker <[email protected]>
#
#################################
#
# Rules for the dictd_t domain.
#
# dictd_exec_t is the type of the dictd executable. # type dictd_t, domain, privlog; type dictd_exec_t, file_type, sysadmfile, exec_type; type var_lib_dictd_t, file_type, sysadmfile; type etc_dictd_t, file_type, sysadmfile;
role system_r types dictd_t;
allow dictd_t init_t:process sigchld;
# Inherit and use descriptors from init.
allow dictd_t init_t:fd inherit_fd_perms;
# read config files
allow dictd_t { etc_t etc_dictd_t }:{ file lnk_file } r_file_perms;domain_auto_trans(initrc_t, dictd_exec_t, dictd_t)
allow dictd_t { root_t etc_t var_lib_dictd_t }:dir r_dir_perms; allow dictd_t var_lib_dictd_t:file r_file_perms;
uses_shlib(dictd_t)
allow dictd_t usr_t:file r_file_perms;
allow dictd_t var_lib_t:dir r_dir_perms;
allow dictd_t self:process { setpgid fork sigchld };
allow dictd_t null_device_t:chr_file rw_file_perms;
allow dictd_t dict_port_t:tcp_socket name_bind;
allow dictd_t devtty_t:chr_file rw_file_perms;
allow dictd_t self:unix_stream_socket create_stream_socket_perms;
can_network(dictd_t)
allow dictd_t domain:tcp_socket { acceptfrom recvfrom }; allow domain dictd_t:tcp_socket { connectto recvfrom };
allow dictd_t fs_t:filesystem getattr;
#
# Author: Russell Coker <[email protected]>
#
#################################
#
# Rules for the radiusd_t domain.
#
# radiusd_exec_t is the type of the radiusd executable. # type radiusd_t, domain, privlog; type radiusd_exec_t, file_type, sysadmfile, exec_type;
role system_r types radiusd_t;
allow radiusd_t init_t:process sigchld;
# Type for files created during execution of radiusdd. type radiusd_var_run_t, file_type, sysadmfile; type etc_radiusd_t, file_type, sysadmfile; type var_log_radiusd_t, file_type, sysadmfile;
file_type_auto_trans(radiusd_t, var_run_t, radiusd_var_run_t)
# Inherit and use descriptors from init.
allow radiusd_t init_t:fd inherit_fd_perms;
allow radiusd_t self:process { setsched signal fork };
# allow pthreads to read kernel version allow radiusd_t sysctl_kernel_t:dir r_dir_perms; allow radiusd_t sysctl_kernel_t:file r_file_perms; # read config files allow radiusd_t etc_radiusd_t:file r_file_perms; allow radiusd_t etc_radiusd_t:dir r_dir_perms;
# write log files allow radiusd_t var_log_radiusd_t:file create_file_perms; allow radiusd_t var_log_radiusd_t:dir create_dir_perms; allow radiusd_t var_log_t:dir r_dir_perms;
allow radiusd_t { etc_t }:dir r_dir_perms;
allow radiusd_t { etc_t resolv_conf_t etc_radiusd_t }:{ file lnk_file } r_file_perms;
allow radiusd_t usr_t:file r_file_perms;
allow radiusd_t null_device_t:chr_file rw_file_perms;
domain_auto_trans(initrc_t, radiusd_exec_t, radiusd_t)
uses_shlib(radiusd_t)can_exec(radiusd_t, lib_t)
allow radiusd_t self:fifo_file rw_file_perms;
allow radiusd_t self:capability { kill setuid setgid dac_override };
can_network(radiusd_t)
allow radiusd_t { radius_port_t radacct_port_t }:udp_socket name_bind;
allow radiusd_t self:unix_stream_socket create_stream_socket_perms;
#
# Created cups policy from lpd policy: Russell Coker <[email protected]>
#################################
#
# Rules for the cupsd_t domain.
#
# cupsd_t is the domain of cupsd. # cupsd_exec_t is the type of the cupsd executable. # type cupsd_t, domain, privlog; role system_r types cupsd_t; every_domain(cupsd_t) type cupsd_exec_t, file_type, sysadmfile, exec_type; type cupsd_spool_t, file_type, sysadmfile; type etc_cupsd_t, file_type, sysadmfile; type var_log_cups_t, file_type, sysadmfile;
domain_auto_trans(initrc_t, cupsd_exec_t, cupsd_t)
type cupsd_tmp_t, file_type, sysadmfile, tmpfile;file_type_auto_trans(cupsd_t, tmp_t, cupsd_tmp_t)
type cupsd_var_run_t, file_type, sysadmfile, pidfile; file_type_auto_trans(cupsd_t, var_run_t, cupsd_var_run_t)
allow cupsd_t etc_cupsd_t:file create_file_perms; allow cupsd_t etc_cupsd_t:dir rw_dir_perms; allow cupsd_t var_log_cups_t:file create_file_perms; allow cupsd_t var_log_cups_t:dir rw_dir_perms; allow cupsd_t proc_t:file r_file_perms; allow cupsd_t proc_t:dir r_dir_perms; can_exec(cupsd_t, cupsd_exec_t)
allow cupsd_t cupsd_exec_t:dir r_dir_perms;
# Use capabilities.
allow cupsd_t cupsd_t:capability { fsetid net_bind_service fowner chown dac_override };
# Inherit and use descriptors from init.
allow cupsd_t init_t:fd inherit_fd_perms;
# Use the network.can_network(cupsd_t)
# Bind to the cups/ipp port (631).
allow cupsd_t ipp_port_t:tcp_socket name_bind;
# Send to portmap.
#can_udp_send(cupsd_t, portmap_t)
# Connect to ypbind.
#can_tcp_connect(cupsd_t, ypbind_t)
# Write to /var/spool/cups.
allow cupsd_t cupsd_spool_t:dir rw_dir_perms; allow cupsd_t cupsd_spool_t:file create_file_perms; allow cupsd_t cupsd_spool_t:file rw_file_perms;
# Filter scripts may be shell scripts, and may invoke progs like /bin/mktemp can_exec(cupsd_t, { shell_exec_t bin_t })
#
# Author: Russell Coker <[email protected]>
#
#################################
#
# Rules for the usbmodules_t domain.
#
type usbmodules_t, domain, privlog;
type usbmodules_exec_t, file_type, sysadmfile, exec_type;
role user_r types usbmodules_t;
role sysadm_r types usbmodules_t;
domain_auto_trans(initrc_t, usbmodules_exec_t, usbmodules_t)
uses_shlib(usbmodules_t)
# allow usb device access allow usbmodules_t usbdevfs_device_t:file rw_file_perms;
allow usbmodules_t { etc_t }:dir r_dir_perms;
#
# Author: Russell Coker <[email protected]>
#
#################################
#
# Rules for the dpkg_t domain.
#
type dpkg_t, domain, admin;
type dpkg_exec_t, file_type, sysadmfile, exec_type; type var_lib_dpkg_t, file_type, sysadmfile; type dpkg_lock_t, file_type, sysadmfile; type tmp_dpkg_t, file_type, sysadmfile, exec_type;
can_exec(dpkg_t, { dpkg_exec_t bin_t shell_exec_t }) file_type_auto_trans(dpkg_t, tmp_t, tmp_dpkg_t) can_exec(dpkg_t, tmp_dpkg_t)
# for apt type apt_t, domain, admin; type apt_exec_t, file_type, sysadmfile, exec_type; type var_lib_apt_t, file_type, sysadmfile; type var_cache_apt_t, file_type, sysadmfile; type etc_apt_t, file_type, sysadmfile;
# when dpkg runs postinst scripts run them in initrc_t domain so that the # daemons are started in the correct context domain_auto_trans(dpkg_t, etc_t, initrc_t)
# allow user domains to execute dpkg
can_exec(user_t, { dpkg_exec_t apt_exec_t })
allow domain { var_lib_dpkg_t var_lib_apt_t var_cache_apt_t }:dir r_dir_perms;
allow domain { var_lib_dpkg_t var_lib_apt_t var_cache_apt_t }:file r_file_perms;# Inherit and use descriptors from any domain. allow { apt_t dpkg_t } domain:fd inherit_fd_perms;
role system_r types { dpkg_t apt_t };
#role sysadm_r types { dpkg_t apt_t };
uses_shlib({ dpkg_t apt_t })
allow dpkg_t proc_t:dir r_dir_perms;
allow dpkg_t proc_t:file r_file_perms;
allow dpkg_t fs_t:filesystem getattr;
allow dpkg_t devtty_t:chr_file rw_file_perms;
allow dpkg_t sysadm_t:process sigchld; allow dpkg_t self:process { sigchld signal fork };
# read/write/create any files in the system
allow dpkg_t file_type:dir create_dir_perms;
allow dpkg_t file_type:{ file lnk_file fifo_file } create_file_perms;
allow dpkg_t file_type:dir { relabelfrom relabelto };
allow dpkg_t file_type:{ file lnk_file fifo_file } { relabelfrom relabelto };
# for non-devfs systems
#allow dpkg_t file_type:{ chr_file blk_file } create_file_perms;# change to the apt_t domain on exec from dpkg_t (dselect) domain_auto_trans(dpkg_t, apt_exec_t, apt_t)
# allow apt to change /var/lib/apt files
allow apt_t { var_lib_apt_t var_cache_apt_t }:dir rw_dir_perms;
allow apt_t { var_lib_apt_t var_cache_apt_t }:file create_file_perms;can_exec(apt_t, { apt_exec_t bin_t sbin_t })
allow apt_t self:process { signal sigchld fork };can_network(apt_t)
allow { apt_t dpkg_t } { var_lib_t bin_t }:dir r_dir_perms;
allow { apt_t dpkg_t } dpkg_lock_t:file rw_file_perms;
# for /proc/meminfo and for "ps"
allow apt_t { proc_t apt_t }:dir r_dir_perms;
allow apt_t { proc_t apt_t }:{ file lnk_file } r_file_perms;
allow apt_t self:fifo_file rw_file_perms;
allow dpkg_t self:fifo_file rw_file_perms;allow apt_t { etc_t etc_apt_t }:dir r_dir_perms;
allow apt_t { etc_t resolv_conf_t etc_apt_t }:{ file lnk_file } r_file_perms;
# apt wants to check available disk space allow apt_t fs_t:filesystem getattr; allow apt_t etc_runtime_t:file r_file_perms;
# auto transition from apt_t to dpkg_t because for 99% of Debian upgrades you # have apt run dpkg. # This means that getting apt_t access is almost as good as dpkg_t which has # as much power as sysadm_t... domain_auto_trans(apt_t, dpkg_exec_t, dpkg_t)
#
# Authors: Russell Coker <[email protected]>
#
#################################
#
# Rules for the sysstat_t domain.
#
# sysstat_exec_t is the type of the sysstat executable. # type sysstat_t, domain, privlog; type sysstat_exec_t, file_type, sysadmfile, exec_type;
role system_r types sysstat_t;
#allow sysstat_t crond_t:process sigchld;
# Type for files created during execution of sysstatd. type var_log_sysstat_t, file_type, sysadmfile;
allow sysstat_t var_log_t:dir r_dir_perms;
allow sysstat_t var_log_sysstat_t:dir rw_dir_perms; allow sysstat_t var_log_sysstat_t:file create_file_perms; allow domain var_log_sysstat_t:dir r_dir_perms; allow domain var_log_sysstat_t:file r_file_perms;
allow sysstat_t etc_t:dir r_dir_perms;
# Inherit and use descriptors from cron.
allow sysstat_t crond_t:fd inherit_fd_perms;
allow sysstat_t crond_t:fifo_file rw_file_perms;
# Use the network.
#allow sysstat_t self:fifo_file { read write }; #allow sysstat_t self:unix_stream_socket create_socket_perms;
# Use capabilities
#allow sysstat_t self:process { setsched signal fork };
# get info from /proc
allow sysstat_t { proc_t sysctl_kernel_t sysctl_t sysctl_fs_t }:dir r_dir_perms;
allow sysstat_t { proc_t sysctl_kernel_t sysctl_t sysctl_fs_t }:file r_file_perms;# read config files
#allow sysstat_t { etc_t etc_sysstat_t }:{ file lnk_file } r_file_perms;domain_auto_trans(system_crond_t, sysstat_exec_t, sysstat_t)
#allow sysstat_t { root_t etc_t }:dir r_dir_perms; uses_shlib(sysstat_t)
#
# Author: Russell Coker <[email protected]>
#
#################################
#
# Rules for the radvd_t domain.
#
type radvd_t, domain, privlog;
type radvd_exec_t, file_type, sysadmfile, exec_type; type etc_radvd_t, file_type, sysadmfile;
role system_r types radvd_t;
# Inherit and use descriptors from init.
allow radvd_t init_t:fd inherit_fd_perms;
allow radvd_t init_t:process sigchld;
# Create pid file.
type radvd_var_run_t, file_type, sysadmfile, pidfile; file_type_auto_trans(radvd_t, var_run_t, radvd_var_run_t)
allow radvd_t self:{ rawip_socket unix_dgram_socket } rw_socket_perms; domain_auto_trans(initrc_t, radvd_exec_t, radvd_t)
###allow radvd_t netmsg_t:packet_socket rw_socket_perms; ###allow radvd_t netmsg_t:rawip_socket rw_socket_perms;
can_network(radvd_t)
uses_shlib(radvd_t)
allow radvd_t proc_t:dir r_dir_perms;
allow radvd_t { proc_t etc_radvd_t }:file r_file_perms; allow radvd_t null_device_t:chr_file rw_file_perms;
allow radvd_t self:process fork;
allow radvd_t sysctl_t:file r_file_perms;
allow radvd_t sysctl_t:dir r_dir_perms;
#
# Author: Russell Coker <[email protected]>
#
# Type for files created during execution of courier. type courier_var_run_t, file_type, sysadmfile;
type etc_courier_t, file_type, sysadmfile;
# allow start scripts to read the config allow initrc_t etc_courier_t:file r_file_perms;
type courier_exec_t, file_type, sysadmfile, exec_type; type sqwebmail_cron_exec_t, file_type, sysadmfile, exec_type;
define(courier_domain',
#################################
#
# Rules for the courier_$1_t domain.
#
# courier_$1_exec_t is the type of the courier_$1 executables. #
type courier_$1_t, domain, privlog;
type courier_$1_exec_t, file_type, sysadmfile, exec_type;
role system_r types courier_$1_t;
allow courier_$1_t init_t:process sigchld; domain_auto_trans(initrc_t, courier_$1_exec_t, courier_$1_t)
file_type_auto_trans(courier_$1_t, var_run_t, courier_var_run_t)
# allow it to read config files etc
allow courier_$1_t { etc_courier_t var_t }:dir r_dir_perms;
allow courier_$1_t etc_courier_t:file r_file_perms;
allow courier_$1_t etc_t:dir r_dir_perms;
allow courier_$1_t etc_t:{ file lnk_file } r_file_perms;# execute scripts etc
allow courier_$1_t { bin_t courier_$1_exec_t }:file rx_file_perms;
allow courier_$1_t bin_t:dir r_dir_perms;
allow courier_$1_t fs_t:filesystem getattr;# set process group and allow permissions over-ride
allow courier_$1_t self:process { setpgid fork sigchld signal };
allow courier_$1_t self:capability dac_override;# Inherit and use descriptors from init.
allow courier_$1_t { newrole_t init_t }:fd inherit_fd_perms; allow courier_$1_t { newrole_t init_t }:process sigchld;
# Use the network.can_network(courier_$1_t)
allow courier_$1_t self:fifo_file { read write getattr }; allow courier_$1_t self:unix_stream_socket create_stream_socket_perms; allow courier_$1_t self:unix_dgram_socket create_socket_perms;
allow courier_$1_t null_device_t:chr_file rw_file_perms;
# allow it to log to /dev/tty allow courier_$1_t devtty_t:chr_file rw_file_perms;
allow courier_$1_t { usr_t etc_runtime_t }:file r_file_perms; allow courier_$1_t usr_t:dir r_dir_perms;
allow courier_$1_t root_t:dir r_dir_perms; can_exec(courier_$1_t, courier_$1_exec_t) can_exec(courier_$1_t, bin_t) uses_shlib(courier_$1_t)
allow courier_$1_t proc_t:dir r_dir_perms;
allow courier_$1_t proc_t:file r_file_perms;
')dnl
courier_domain(authdaemon)
# should not be needed!
allow courier_authdaemon_t user_home_t:dir r_dir_perms;
allow courier_authdaemon_t self:unix_stream_socket connectto;
allow courier_authdaemon_t self:capability { setuid setgid };courier_domain(tcpd)
allow courier_tcpd_t self:capability net_bind_service; allow courier_tcpd_t sbin_t:dir r_dir_perms;
# for TLS
allow courier_tcpd_t random_device_t:chr_file read;
can_exec(courier_tcpd_t, courier_exec_t)
allow courier_authdaemon_t courier_tcpd_t:{ unix_stream_socket tcp_socket } rw_stream_socket_perms;# domain for pop and imap
courier_domain(pop)
domain_auto_trans(courier_tcpd_t, courier_pop_exec_t, courier_pop_t)
allow courier_tcpd_t courier_pop_exec_t:file read;
allow courier_pop_t courier_tcpd_t:{ unix_stream_socket tcp_socket } rw_stream_socket_perms;
domain_auto_trans(courier_pop_t, courier_authdaemon_exec_t, courier_authdaemon_t)
allow courier_pop_t courier_authdaemon_exec_t:file read;
allow courier_pop_t courier_authdaemon_t:tcp_socket rw_stream_socket_perms;
allow courier_authdaemon_t courier_tcpd_t:fd use;
allow courier_authdaemon_t courier_tcpd_t:tcp_socket rw_stream_socket_perms;
allow courier_authdaemon_t courier_tcpd_t:fifo_file rw_file_perms;
allow courier_pop_t courier_authdaemon_t:process sigchld;
domain_auto_trans(courier_authdaemon_t, courier_pop_exec_t, courier_pop_t)
allow courier_authdaemon_t courier_pop_exec_t:file read;# do the actual work (read the Maildir)
allow courier_pop_t user_home_t:dir rw_dir_perms;
allow courier_pop_t user_home_t:file r_file_perms;
allow courier_pop_t user_home_t:file { rename unlink };# for calendaring courier_domain(pcp)
allow courier_pcp_t courier_pcp_t:capability { setuid setgid };
# for webmail courier_domain(sqwebmail) domain_auto_trans(system_crond_t, sqwebmail_cron_exec_t, courier_sqwebmail_t) allow courier_sqwebmail_t crond_t:fd use; allow courier_sqwebmail_t crond_t:fifo_file rw_file_perms;
Quoted 9 lines · Russell Coker
The above is about 30% of the policy changes I've made as compared to the sample policy shipped on the NSA site. It's difficult for me to send out anything else in a mergable form (sending a tar file of my policy directory probably won't be very helpful) as the rest is either too experimental, or has dependencies on some of the things in this message.
Steve, could you please make available a patch between the released policy and the policy that is in your internal CVS for the next public release so I can follow the next development and provide suitable additions and patches?
Thanks for your work on the policy. While I can see the importance of merging your patches to existing elements of the example policy, I'm not sure whether it is really optimal for us to serve as a chokepoint for all of your new domains. Again, it might be a good idea to start maintaining a separate policy tree on sourceforge.
--
Stephen D. Smalley, NAI Labs
[email protected]
--
You have received this message because you are subscribed to the selinux list. If you no longer wish to subscribe, send mail to [email protected] with the words "unsubscribe selinux" without quotes as the message.