Skip to contentSkip to conversation

splitting global_macros.te

DISCUSSION Russell Coker 1 participant 1 message Aug 1, 2003 SELinux security module

lore
Share & tools
lore
#0 lore raw

In my tree I have split the global_macros.te into two files, the other file core_macros.te is for the basic macros which are very unlikely to change.

Changing the macros in core_macros.te should almost never be necessary, and making them different to what I have in that file (which are provided on the NSA site in the global_macros.te) will almost always be a mistake.

The macros in global_macros.te are widely used in the policy, but can be easily changed if necessary without breaking much (and while still preserving some level of compatability with the default policy).

The global_macros.te file as distributed by the NSA is the largest file in the policy, which is one of the reasons for splitting it (smaller source files are easier to read and comprehend). Now the two smaller macros files that I have attached are the two largest files in my policy tree.

The third largest file is user_macros.te (which also needs work).

Howard, I encourage you to make similar changes to your policy tree.

Please note that these files are a split of my previous global_macros.te not the one from the NSA site. I have removed several deprecated macros from the version in my tree, while those macros are still in the NSA tree.

Signature · 4 lines
http://www.coker.com.au/selinux/   My NSA Security Enhanced Linux packages
http://www.coker.com.au/bonnie++/  Bonnie++ hard drive benchmark
http://www.coker.com.au/postal/    Postal SMTP/POP benchmark
http://www.coker.com.au/~russell/  My home page

##############################
#

# core macros for the type enforcement (TE) configuration.
#

#
# Authors: Stephen Smalley <[email protected]> and Timothy Fraser # Modified: Howard Holm (NSA), <[email protected]>
# System V IPC added
#

#################################
#
# Macros for groups of classes and

# groups of permissions.
#

#
# All directory and file classes
#
define(dir_file_class_set', { dir file lnk_file sock_file fifo_file chr_file blk_file }')

#
# All non-directory file classes.
#
define(file_class_set', { file lnk_file sock_file fifo_file chr_file blk_file }')

#
# Non-device file classes.
#
define(notdevfile_class_set', { file lnk_file sock_file fifo_file }')

#
# Device file classes.
#
define(devfile_class_set', { chr_file blk_file }')

#
# All socket classes.
#
define(socket_class_set', { tcp_socket udp_socket rawip_socket netlink_socket packet_socket unix_stream_socket unix_dgram_socket }')

#
# Datagram socket classes.
#
define(dgram_socket_class_set', { udp_socket unix_dgram_socket }')

#
# Stream socket classes.
#
define(stream_socket_class_set', { tcp_socket unix_stream_socket }')

#
# Unprivileged socket classes (exclude rawip, netlink, packet).
#
define(unpriv_socket_class_set', { tcp_socket udp_socket unix_stream_socket unix_dgram_socket }')

#
# Permissions for getting file attributes.
#
define(stat_file_perms', { getattr }')

#
# Permissions for executing files.
#
define(x_file_perms', { getattr execute }')

#
# Permissions for reading files and their attributes. #
define(r_file_perms', { read getattr lock ioctl }')

#
# Permissions for reading and executing files.
#
define(rx_file_perms', { read getattr lock execute ioctl }')

#
# Permissions for reading and writing files and their attributes. #
define(rw_file_perms', { ioctl read getattr lock write append }')

#
# Permissions for reading and appending to files.
#
define(ra_file_perms', { ioctl read getattr lock append }')

#
# Permissions for linking, unlinking and renaming files. #
define(link_file_perms', { getattr link unlink rename }')

#
# Permissions for creating and using files.
#
define(create_file_perms', { create ioctl read getattr lock write setattr append link unlink rename }')

#
# Permissions for reading directories and their attributes. #
define(r_dir_perms', { read getattr lock search ioctl }')

#
# Permissions for reading and writing directories and their attributes.
#
define(rw_dir_perms', { read getattr lock search ioctl add_name remove_name write }')

#
# Permissions for reading and adding names to directories.
#
define(ra_dir_perms', { read getattr lock search ioctl add_name write }')

#
# Permissions for creating and using directories.
#
define(create_dir_perms', { create read getattr lock setattr link unlink rename search add_name remove_name reparent write rmdir }')

#
# Permissions to mount and unmount file systems.
#
define(mount_fs_perms', { mount remount unmount getattr }')

#
# Permissions for using sockets.
#
define(rw_socket_perms', { ioctl read getattr write setattr append bind connect getopt setopt shutdown }')

#
# Permissions for creating and using sockets.
#
define(create_socket_perms', { create ioctl read getattr write setattr append bind connect getopt setopt shutdown }')

#
# Permissions for using stream sockets.
#
define(rw_stream_socket_perms', { ioctl read getattr write setattr append bind connect getopt setopt shutdown listen accept }')

#
# Permissions for creating and using stream sockets.
#
define(create_stream_socket_perms', { create ioctl read getattr write setattr append bind connect getopt setopt shutdown listen accept }')

#
# Permissions for sending all signals.
#
define(signal_perms', { sigchld sigkill sigstop signull signal }')

#
# Permissions for sending and receiving network packets.
#
define(packet_perms', { tcp_recv tcp_send udp_recv udp_send rawip_recv rawip_send }')

#
# Permissions for using System V IPC
#
define(r_sem_perms', { associate getattr read unix_read }')
define(rw_sem_perms', { associate getattr read write unix_read unix_write }') define(create_sem_perms', { associate getattr setattr create destroy read write unix_read unix_write }') define(r_msgq_perms', { associate getattr read unix_read }')
define(rw_msgq_perms', { associate getattr read write enqueue unix_read unix_write }') define(create_msgq_perms', { associate getattr setattr create destroy read write enqueue unix_read unix_write }') define(r_shm_perms', { associate getattr read unix_read }')
define(rw_shm_perms', { associate getattr read write lock unix_read unix_write }') define(create_shm_perms', { associate getattr setattr create destroy read write lock unix_read unix_write }')

#################################
#
# Macros for type transition rules and

# access vector rules.
#

#
# Simple combinations for reading and writing both

# directories and files.
# 
define(`r_dir_file', `
allow $1 $2:dir r_dir_perms;
allow $1 $2:{ file lnk_file } r_file_perms;
')

define(rw_dir_file',
allow $1 $2:dir rw_dir_perms;
allow $1 $2:{ file lnk_file } rw_file_perms;
')

define(ra_dir_file',
allow $1 $2:dir ra_dir_perms;
allow $1 $2:{ file lnk_file } ra_file_perms;
')

define(rw_dir_create_file',
allow $1 $2:dir rw_dir_perms;
allow $1 $2:{ file lnk_file } create_file_perms;
')

define(create_dir_file',
allow $1 $2:dir create_dir_perms;
allow $1 $2:{ file lnk_file } create_file_perms;
')

define(create_dir_notdevfile',
allow $1 $2:dir create_dir_perms;
allow $1 $2:notdevfile_class_set create_file_perms; ')

define(create_append_log_file',
allow $1 $2:dir { read getattr search add_name write }; allow $1 $2:file { create ioctl getattr setattr append link }; ')

##################################
#
# can_getsecurity(domain)
#
# Authorize a domain to get security policy decisions.
#
define(can_getsecurity',
allow $1 security_t:dir { read search getattr };
allow $1 security_t:file { getattr read write };
allow $1 security_t:security { compute_av context_to_sid sid_to_context }; ')

##################################
#
# can_loadpol(domain)
#
# Authorize a domain to load a policy configuration. # Due to its sensitivity, always audit this permission. #
define(can_loadpol',
allow $1 security_t:dir { read search getattr }; allow $1 security_t:file { getattr read write }; allow $1 security_t:security load_policy; auditallow $1 security_t:security load_policy; ')

#################################
#
# domain_trans(parent_domain, program_type, child_domain) #
# Permissions for transitioning to a new domain. #

define(domain_trans',

#
# Allow the process to transition to the new domain. #
allow $1 $3:process transition;

#
# Allow the process to execute the program.
#
allow $1 $2:file { read x_file_perms };

#
# Allow the process to reap the new domain.
#
allow $3 $1:process sigchld;

#
# Allow the new domain to inherit and use file

# descriptions from the creating process and vice versa.
#
allow $3 $1:fd use;
allow $1 $3:fd use;

#
# Allow the new domain to write back to the old domain via a pipe. #
allow $3 $1:fifo_file rw_file_perms;

#
# Allow the new domain to read and execute the program. #
allow $3 $2:file rx_file_perms;

#
# Allow the new domain to be entered via the program. #
allow $3 $2:file entrypoint;
')

#################################
#
# domain_auto_trans(parent_domain, program_type, child_domain) #
# Define a default domain transition and allow it.
#
define(domain_auto_trans',
domain_trans($1,$2,$3)
type_transition $1 $2:process $3;
')

#################################
#
# can_ptrace(domain, domain)
#
# Permissions for running ptrace (strace or gdb) on another domain #
define(can_ptrace',
allow $1 $2:process ptrace;
')

#################################
#
# can_exec(domain, type)
#
# Permissions for executing programs with

# a specified type without changing domains.
#
define(`can_exec',`
allow $1 $2:file { rx_file_perms execute_no_trans };
')

#################################
#
# file_type_trans(domain, dir_type, file_type) #
# Permissions for transitioning to a new file type. #

define(file_type_trans',

#
# Allow the process to modify the directory.
#
allow $1 $2:dir rw_dir_perms;

#
# Allow the process to create the file.
#
ifelse($4', ', `
allow $1 $3:notdevfile_class_set create_file_perms; allow $1 $3:dir create_dir_perms;
', `
ifelse($4', dir', `
allow $1 $3:$4 create_dir_perms;
', `
allow $1 $3:$4 create_file_perms;
')dnl end if dir
')dnl end if param 4 specified

')

#################################
#
# file_type_auto_trans(creator_domain, parent_directory_type, file_type, object_class) #

# the object class will default to notdevfile_class_set if not specified as
# the fourth parameter
#
# Define a default file type transition and allow it.
#
define(`file_type_auto_trans',`
ifelse(`$4', `', `
file_type_trans($1,$2,$3)
type_transition $1 $2:dir $3;
type_transition $1 $2:notdevfile_class_set $3;
', `
file_type_trans($1,$2,$3,$4)
type_transition $1 $2:$4 $3;
')

')

#################################
#
# can_unix_connect(client, server)
#
# Permissions for establishing a Unix stream connection. #
define(can_unix_connect',
allow $1 $2:unix_stream_socket connectto;
')

#################################
#
# can_unix_send(sender, receiver)
#
# Permissions for sending Unix datagrams.
#
define(can_unix_send',
allow $1 $2:unix_dgram_socket sendto;
')

#################################
#
# can_tcp_connect(client, server)
#
# Permissions for establishing a TCP connection.
#
define(can_tcp_connect',
allow $1 $2:tcp_socket { connectto recvfrom };
allow $2 $1:tcp_socket { acceptfrom recvfrom };
allow $2 tcp_socket_t:tcp_socket { recvfrom };
allow $1 tcp_socket_t:tcp_socket { recvfrom };
')

#################################
#
# can_udp_send(sender, receiver)
#
# Permissions for sending/receiving UDP datagrams. #
define(can_udp_send',
allow $1 $2:udp_socket { sendto };
allow $2 $1:udp_socket { recvfrom };
')

#
# general_domain_access(domain)
#
# Grant permissions within the domain.
# This includes permissions to processes, /proc/PID files,

# file descriptors, pipes, Unix sockets, and System V IPC objects
# labeled with the domain.
#
define(`general_domain_access',`
# Access other processes in the same domain.
allow $1 self:process ~ptrace;

# Access /proc/PID files for processes in the same domain. allow $1 self:dir r_dir_perms;
allow $1 self:notdevfile_class_set r_file_perms;

# Access file descriptions, pipes, and sockets

# created by processes in the same domain.
allow $1 self:fd *;
allow $1 self:fifo_file rw_file_perms;
allow $1 self:unix_dgram_socket create_socket_perms;
allow $1 self:unix_stream_socket create_stream_socket_perms;

# Allow the domain to communicate with other processes in the same domain. allow $1 self:unix_dgram_socket sendto;
allow $1 self:unix_stream_socket connectto;

# Access System V IPC objects created by processes in the same domain. allow $1 self:sem create_sem_perms;
allow $1 self:msg { send receive };
allow $1 self:msgq create_msgq_perms;
allow $1 self:shm create_shm_perms;
')

##############################
#
# Global macros for the type enforcement (TE) configuration. #

#
# Authors: Stephen Smalley <[email protected]> and Timothy Fraser # Modified: Howard Holm (NSA), <[email protected]>
# System V IPC added
#
# Russell Coker <[email protected]>
#

#################################
#
# uses_shlib(domain)
#
# Permissions for using shared libraries.
#
define(uses_shlib',
allow $1 { root_t usr_t lib_t etc_t }:dir r_dir_perms; allow $1 lib_t:lnk_file r_file_perms;
allow $1 lib_t:file r_file_perms;
allow $1 usr_t:{ file lnk_file } r_file_perms; allow $1 ld_so_t:file rx_file_perms;
allow $1 ld_so_t:file execute_no_trans;
allow $1 ld_so_t:lnk_file r_file_perms;
allow $1 shlib_t:file rx_file_perms;
allow $1 shlib_t:lnk_file r_file_perms;
allow $1 ld_so_cache_t:file r_file_perms; allow $1 device_t:dir search;
allow $1 null_device_t:chr_file rw_file_perms; ')

#################################
#
# can_exec_any(domain)
#
# Permissions for executing a variety

# of executable types.
#
define(`can_exec_any',`
allow $1 { bin_t sbin_t lib_t etc_t }:dir r_dir_perms;
allow $1 { bin_t sbin_t etc_t }:lnk_file { getattr read };
uses_shlib($1)
can_exec($1, etc_t)
can_exec($1, lib_t)
can_exec($1, bin_t)
can_exec($1, sbin_t)
can_exec($1, exec_type)
')

#################################
#
# can_network(domain)
#
# Permissions for accessing the network.
# See types/network.te for the network types.
# See net_contexts for security contexts for network entities. #
define(can_network',
#
# Allow the domain to create and use UDP and TCP sockets. # Other kinds of sockets must be separately authorized for use. allow $1 self:udp_socket create_socket_perms;
allow $1 self:tcp_socket create_stream_socket_perms;

#
# Allow the domain to send UDP packets.
# Since the destination sockets type is unknown, the generic

# any_socket_t type is used as a placeholder.
#
allow $1 any_socket_t:udp_socket sendto;

#
# Allow the domain to send using any network interface.

# netif_type is a type attribute for all network interface types.
#
allow $1 netif_type:netif { tcp_send udp_send rawip_send };

#
# Allow packets sent by the domain to be received on any network interface. #
allow $1 netif_type:netif { tcp_recv udp_recv rawip_recv };

#
# Allow the domain to receive packets from any network interface.

# netmsg_type is a type attribute for all default message types.
#
allow $1 netmsg_type:{ udp_socket tcp_socket rawip_socket } recvfrom;

#
# Allow the domain to initiate or accept TCP connections

# on any network interface.
#
allow $1 netmsg_type:tcp_socket { connectto acceptfrom };

#
# Receive resets from the TCP reset socket.
# The TCP reset socket is labeled with the tcp_socket_t type. #
allow $1 tcp_socket_t:tcp_socket recvfrom;

dontaudit $1 tcp_socket_t:tcp_socket connectto;

#
# Allow the domain to send to any node.

# node_type is a type attribute for all node types.
#
allow $1 node_type:node { tcp_send udp_send rawip_send };

#
# Allow packets sent by the domain to be received from any node. #
allow $1 node_type:node { tcp_recv udp_recv rawip_recv };

#
# Allow the domain to send NFS client requests via the socket

# created by mount.
#
allow $1 mount_t:udp_socket rw_socket_perms;

#
# Bind to the default port type.
# Other port types must be separately authorized.
#
#allow $1 port_t:udp_socket name_bind;
#allow $1 port_t:tcp_socket name_bind;
')

#################################
#
# can_sysctl(domain)
#
# Permissions for modifying sysctl parameters.
#
define(can_sysctl',
allow $1 sysctl_t:dir r_dir_perms;
allow $1 sysctl_t:file { setattr rw_file_perms }; allow $1 sysctl_fs_t:dir r_dir_perms;
allow $1 sysctl_fs_t:file { setattr rw_file_perms }; allow $1 sysctl_kernel_t:dir r_dir_perms;
allow $1 sysctl_kernel_t:file { setattr rw_file_perms }; allow $1 sysctl_net_t:dir r_dir_perms;
allow $1 sysctl_net_t:file { setattr rw_file_perms }; allow $1 sysctl_net_unix_t:dir r_dir_perms;
allow $1 sysctl_net_unix_t:file { setattr rw_file_perms }; allow $1 sysctl_vm_t:dir r_dir_perms;
allow $1 sysctl_vm_t:file { setattr rw_file_perms }; allow $1 sysctl_dev_t:dir r_dir_perms;
allow $1 sysctl_dev_t:file { setattr rw_file_perms }; allow $1 sysctl_modprobe_t:file { setattr rw_file_perms }; ')

##################################
#
# base_pty_perms(domain_prefix)
#
# Base permissions used for can_create_pty() and can_create_other_pty() #
define(base_pty_perms',
# Access the pty master multiplexer.
allow $1_t ptmx_t:chr_file rw_file_perms;

ifdef(devfsd.te',
allow $1_t device_t:filesystem getattr;
')
allow $1_t devpts_t:filesystem getattr;

# allow searching /dev/pts
allow $1_t devpts_t:dir { getattr read search };
')

##################################
#
# can_create_pty(domain_prefix, attributes) #
# Permissions for creating ptys.
#
define(can_create_pty',
base_pty_perms($1)
type $1_devpts_t, file_type, sysadmfile, ptyfile $2;

# Allow the pty to be associated with the file system. allow $1_devpts_t devpts_t:filesystem associate;

# Label pty files with a derived type. type_transition $1_t devpts_t:chr_file $1_devpts_t;

# Read and write my pty files.
allow $1_t $1_devpts_t:chr_file { setattr rw_file_perms }; ')

##################################
#
# can_create_other_pty(domain_prefix,other_domain) #
# Permissions for creating ptys for another domain. #
define(can_create_other_pty', base_pty_perms($1)
# Label pty files with a derived type. type_transition $1_t devpts_t:chr_file $2_devpts_t;

# Read and write pty files.
allow $1_t $2_devpts_t:chr_file { setattr rw_file_perms }; ')

##################################
#
# read_locale(domain)
#
# Permissions for reading the locale data,

# /etc/localtime and the files that it links to
#
define(`read_locale', `
allow $1 etc_t:lnk_file read;
r_dir_file($1, locale_t)
')

#
# general_proc_read_access(domain)
#
# Grant read/search permissions to most of /proc, excluding

# the /proc/PID directories and the /proc/kmsg and /proc/kcore files.
# The general_domain_access macro grants access to the domain /proc/PID
# directories, but not to other domains.  Only permissions to stat
# are granted for /proc/kmsg and /proc/kcore, since these files are more
# sensitive.
# 
define(`general_proc_read_access',`
# Read system information files in /proc.
allow $1 proc_t:dir r_dir_perms;
allow $1 proc_t:notdevfile_class_set r_file_perms;

# Stat /proc/kmsg and /proc/kcore.
allow $1 proc_kmsg_t:file stat_file_perms;
allow $1 proc_kcore_t:file stat_file_perms;

# Read system variables in /proc/sys.
allow $1 sysctl_modprobe_t:file r_file_perms;
allow $1 sysctl_t:file r_file_perms;
allow $1 sysctl_t:dir r_dir_perms;
allow $1 sysctl_fs_t:file r_file_perms;
allow $1 sysctl_fs_t:dir r_dir_perms;
allow $1 sysctl_kernel_t:file r_file_perms;
allow $1 sysctl_kernel_t:dir r_dir_perms;
allow $1 sysctl_net_t:file r_file_perms;
allow $1 sysctl_net_t:dir r_dir_perms;
allow $1 sysctl_vm_t:file r_file_perms;
allow $1 sysctl_vm_t:dir r_dir_perms;
allow $1 sysctl_dev_t:file r_file_perms;
allow $1 sysctl_dev_t:dir r_dir_perms;
')

#
# base_file_read_access(domain)
#
# Grant read/search permissions to a few system file types. #
define(base_file_read_access',
# Read /.
allow $1 root_t:dir r_dir_perms;
allow $1 root_t:notdevfile_class_set r_file_perms;

# Read /home.
allow $1 home_root_t:dir r_dir_perms;

# Read /usr.
allow $1 usr_t:dir r_dir_perms;
allow $1 usr_t:notdevfile_class_set r_file_perms;

# Read bin and sbin directories.
allow $1 bin_t:dir r_dir_perms;
allow $1 bin_t:notdevfile_class_set r_file_perms; allow $1 sbin_t:dir r_dir_perms;
allow $1 sbin_t:notdevfile_class_set r_file_perms; ')

#######################
# daemon_base_domain(domain_prefix, attribs)
#
# Define a daemon domain with a base set of type declarations

# and permissions that are common to most daemons.
# attribs is the list of attributes which must start with "," if it is not empty
#
# Author:  Russell Coker <[email protected]>
#
define(`daemon_base_domain', `
type $1_t, domain, privlog $2;
type $1_exec_t, file_type, sysadmfile, exec_type;

role system_r types $1_t;

domain_auto_trans(initrc_t, $1_exec_t, $1_t)

# Inherit and use descriptors from init.
allow $1_t init_t:fd use;
allow $1_t init_t:process sigchld;
allow $1_t privfd:fd use;
ifdef(newrole.te', allow $1_t newrole_t:process sigchld;') allow $1_t self:process { signal_perms fork };

uses_shlib($1_t)

allow $1_t { self proc_t }:dir r_dir_perms;
allow $1_t { self proc_t }:lnk_file read;

allow $1_t device_t:dir { getattr search }; allow $1_t null_device_t:chr_file rw_file_perms; allow $1_t console_device_t:chr_file rw_file_perms; allow $1_t initrc_devpts_t:chr_file rw_file_perms; ')dnl

# allow a domain to create its own files under /var/run and to create files
# in directories that are created for it.  For sock_file etc you need to add
# your own rules
define(`var_run_domain', `
type $1_var_run_t alias var_run_$1_t, file_type, sysadmfile, pidfile;
file_type_auto_trans($1_t, var_run_t, $1_var_run_t, file)
allow $1_t $1_var_run_t:dir rw_dir_perms;
')

define(daemon_domain',
daemon_base_domain($1, `$2')
# Create pid file.
allow $1_t var_t:dir { getattr search };
var_run_domain($1)

allow $1_t devtty_t:chr_file rw_file_perms;

# for daemons that look at /root on startup
dontaudit $1_t sysadm_home_dir_t:dir search;
# for df
allow $1_t fs_type:filesystem getattr;

read_locale($1_t)
')dnl

define(`uses_authbind',
`domain_auto_trans($1, authbind_exec_t, authbind_t) allow authbind_t $1:process sigchld;
allow authbind_t $1:fd use;
allow authbind_t $1:{ tcp_socket udp_socket } rw_socket_perms; ')

# define a sub-domain, $1_t is the parent domain, $2 is the name
# of the sub-domain.
#
define(`daemon_sub_domain', `
# $1 is the parent domain (or domains), $2_t is the child domain,
# and $3 is any attributes to apply to the child
type $2_t, domain, privlog $3;
type $2_exec_t, file_type, sysadmfile, exec_type;

role system_r types $2_t;

domain_auto_trans($1, $2_exec_t, $2_t)

# Inherit and use descriptors from parent.
allow $2_t $1:fd use;
allow $2_t $1:process sigchld;

allow $2_t self:process signal_perms;

uses_shlib($2_t)

allow $2_t { self proc_t }:dir r_dir_perms;
allow $2_t { self proc_t }:lnk_file read;

allow $2_t device_t:dir getattr;
')

define(tmp_domain',
type $1_tmp_t, file_type, sysadmfile, tmpfile $2;
file_type_auto_trans($1_t, tmp_t, $1_tmp_t)
')

define(tmpfs_domain',
type $1_tmpfs_t, file_type, sysadmfile, tmpfsfile; # Use this type when creating tmpfs/shm objects. file_type_auto_trans($1_t, tmpfs_t, $1_tmpfs_t) allow $1_tmpfs_t tmpfs_t:filesystem associate; ')

define(var_lib_domain',
type $1_var_lib_t alias var_lib_$1_t, file_type, sysadmfile; file_type_auto_trans($1_t, var_lib_t, $1_var_lib_t) ')

define(log_domain',
type $1_log_t, file_type, sysadmfile, logfile;
file_type_auto_trans($1_t, var_log_t, $1_log_t)
')

define(lock_domain',
type $1_lock_t, file_type, sysadmfile, lockfile; file_type_auto_trans($1_t, var_lock_t, $1_lock_t, file) ')

#######################
# application_domain(domain_prefix)
#
# Define a domain with a base set of type declarations

# and permissions that are common to simple applications.
#
# Author:  Russell Coker <[email protected]>
#
define(`application_domain', `
type $1_t, domain, privlog;
type $1_exec_t, file_type, sysadmfile, exec_type;
role sysadm_r types $1_t;
domain_auto_trans(sysadm_t, $1_exec_t, $1_t)
uses_shlib($1_t)
')

define(user_application_domain',
application_domain($1)
in_user_role($1_t)
domain_auto_trans(userdomain, $1_exec_t, $1_t)
')

define(system_domain',
type $1_t, domain, privlog $2;
type $1_exec_t, file_type, sysadmfile, exec_type;
role system_r types $1_t;
uses_shlib($1_t)
allow $1_t etc_t:dir r_dir_perms;
')