## Guide to the Secure Configuration of Red Hat Enterprise Linux 6

The SCAP Security Guide Project
https://www.open-scap.org/security-policies/scap-security-guide
This guide presents a catalog of security-relevant configuration settings for Red Hat Enterprise Linux 6. It is a rendering of content structured in the eXtensible Configuration Checklist Description Format (XCCDF) in order to support security automation. The SCAP content is is available in the config_item="scap-security-guide" package which is developed at https://www.open-scap.org/security-policies/scap-security-guide.
Providing system administrators with such guidance informs them how to securely configure systems under their control in a variety of network roles. Policy makers and baseline creators can use this catalog of settings, with its associated references to higher-level security control catalogs, in order to assist them in security baseline creation. This guide is a italics="catalog, not a checklist," and satisfaction of every item is not likely to be possible or sensible in many operational scenarios. However, the XCCDF format enables granular selection and adjustment of settings, and their association with OVAL and OCIL content provides an automated checking capability. Transformations of this document, and its associated automated checking content, are capable of providing baselines that meet a diverse set of policy objectives. Some example XCCDF italics="Profiles", which are selections of items that form checklists and can be used as baselines, are available with this guide. They can be processed, in an automated fashion, with tools that support the Security Content Automation Protocol (SCAP). The DISA STIG for Red Hat Enterprise Linux 6, which provides required settings for US Department of Defense systems, is one example of a baseline created from this guidance.
Do not attempt to implement any of the settings in this guide without first testing them in a non-operational environment. The creators of this guidance assume no responsibility whatsoever for its use by other parties, and makes no guarantees, expressed or implied, about its quality, reliability, or any other characteristic.

Profile ID | (default)

## Revision History

Current version: 0.1.39

- draft (as of 2018-07-26)

## Platforms

- cpe:/o:redhat:enterprise_linux:6
- cpe:/o:redhat:enterprise_linux:6::client
- cpe:/o:redhat:enterprise_linux:6::computenode

## Table of Contents

1. Remediation functions used by the SCAP Security Guide Project
2. Services

1. FTP Server
2. Web Server
3. System Security Services Daemon
4. DHCP
5. Network Time Protocol
6. Print Support
7. SNMP Server
8. Obsolete Services
9. Cron and At Daemons
10. NFS and RPC
11. Base Services
12. SSH Server
13. DNS Server
14. LDAP
15. Mail Server Software
16. Avahi Server
17. X Window System
18. IMAP and POP3 Server
19. Samba(SMB) Microsoft Windows File Sharing Server
20. Proxy Server

3. System Settings

1. Configure Syslog
2. Network Configuration and Firewalls
3. SELinux
4. Account and Access Control
5. Protect Random-Number Entropy Pool
6. File Permissions and Masks
7. System Accounting with <tt>auditd</tt>
8. Installing and Maintaining Software

## Checklist

### Remediation functions used by the SCAP Security Guide Project [ref]group

XCCDF form of the various remediation functions as used by remediation scripts from the SCAP Security Guide Project.

### Services [ref]group

The best protection against vulnerable software is running less software. This section describes how to review the software which Red Hat Enterprise Linux 6 installs on a system and disable software which is not needed. It then enumerates the software packages installed on a default Red Hat Enterprise Linux 6 system and provides guidance about which ones can be safely disabled.
Red Hat Enterprise Linux 6 provides a convenient minimal install option that essentially installs the bare necessities for a functional system. When building Red Hat Enterprise Linux 6 systems, it is highly recommended to select the minimal packages and then build up the system from there.

### FTP Server [ref]group

FTP is a common method for allowing remote access to files. Like telnet, the FTP protocol is unencrypted, which means that passwords and other data transmitted during the session can be captured and that the session is vulnerable to hijacking. Therefore, running the FTP server software is not recommended.
However, there are some FTP server configurations which may be appropriate for some environments, particularly those which allow only read-only anonymous access as a means of downloading data available to the public.

### Use vsftpd to Provide FTP Service if Necessary [ref]group

The primary vsftpd configuration file is `/etc/vsftpd.conf`, if that file exists, or `/etc/vsftpd/vsftpd.conf` if it does not.

### Restrict the Set of Users Allowed to Access FTP [ref]group

This section describes how to disable non-anonymous (password-based) FTP logins, or, if it is not possible to do this entirely due to legacy applications, how to restrict insecure FTP login to only those users who have an identified need for this access.

### Use vsftpd to Provide FTP Service if Necessary [ref]group

If your use-case requires FTP service, install and set-up vsftpd to provide it.

### Disable vsftpd if Possible [ref]group

To minimize attack surface, disable vsftpd if at all possible.

### Web Server [ref]group

The web server is responsible for providing access to content via the HTTP protocol. Web servers represent a significant security risk because:

- The HTTP port is commonly probed by malicious sources
- Web server software is very complex, and includes a long history of vulnerabilities
- The HTTP protocol is unencrypted and vulnerable to passive monitoring

The system's default web server software is Apache 2 and is provided in the RPM package `httpd`.

### Install Apache if Necessary [ref]group

If `httpd` was not installed and activated, but the system needs to act as a web server, then it should be installed on the system. Follow these guidelines to install it defensively. The `httpd` package can be installed with the following command:

    $ sudo yum install httpd

This method of installation is recommended over installing the "Web Server" package group during the system installation process. The Web Server package group includes many packages which are likely extraneous, while the command-line method installs only the required `httpd` package itself.

### Confirm Minimal Built-in Modules Installed [ref]group

The default `httpd` installation minimizes the number of modules that are compiled directly into the binary (`core prefork http_core mod_so`). This minimizes risk by limiting the capabilities allowed by the web server. Query the set of compiled-in modules using the following command:

    $ httpd -l

If the number of compiled-in modules is significantly larger than the aforementioned set, this guide recommends re-installing `httpd` with a reduced configuration. Minimizing the number of modules that are compiled into the `httpd` binary, reduces risk by limiting the capabilities allowed by the webserver.

### Disable Apache if Possible [ref]group

If Apache was installed and activated, but the system does not need to act as a web server, then it should be disabled and removed from the system.

### Secure Apache Configuration [ref]group

The `httpd` configuration file is `/etc/httpd/conf/httpd.conf`. Apply the recommendations in the remainder of this section to this file.

### Restrict Web Server Information Leakage [ref]group

The `ServerTokens` and `ServerSignature` directives determine how much information the web server discloses about the configuration of the system.

### Configure Operating System to Protect Web Server [ref]group

The following configuration steps should be taken on the system which hosts the web server, in order to provide as safe an environment as possible for the web server.

### Configure <tt>iptables</tt> to Allow Access to the Web Server [ref]group

By default, `iptables` blocks access to the ports used by the web server. To configure `iptables` to allow port 80 traffic one must edit `/etc/sysconfig/iptables` and `/etc/sysconfig/ip6tables` (if IPv6 is in use). Add the following line, ensuring that it appears before the final LOG and DROP lines for the INPUT chain:

    -A INPUT -m state --state NEW -p tcp --dport 80 -j ACCEPT

To configure `iptables` to allow port 443 traffic one must edit `/etc/sysconfig/iptables` and `/etc/sysconfig/ip6tables` (if IPv6 is in use). Add the following line, ensuring that it appears before the final LOG and DROP lines for the INPUT chain:

    -A INPUT -m state --state NEW -p tcp --dport 443 -j ACCEPT

### Run <tt>httpd</tt> in a <tt>chroot</tt> Jail if Practical [ref]group

Running `httpd` inside a `chroot` jail is designed to isolate the web server process to a small section of the filesystem, limiting the damage if it is compromised. Versions of Apache greater than 2.2.10 (such as the one included with Red Hat Enterprise Linux 6) provide the `ChrootDir` directive. To run Apache inside a chroot jail in `/chroot/apache`, add the following line to `/etc/httpd/conf/httpd.conf`:

    ChrootDir /chroot/apache

This necessitates placing all files required by `httpd` inside `/chroot/apache` , including `httpd`'s binaries, modules, configuration files, and served web pages. The details of this configuration are beyond the scope of this guide. This may also require additional SELinux configuration.

### Restrict File and Directory Access [ref]group

Minimize access to critical `httpd` files and directories.

### Use Denial-of-Service Protection Modules [ref]group

Denial-of-service attacks are difficult to detect and prevent while maintaining acceptable access to authorized users. However, some traffic-shaping modules can be used to address the problem. Well-known DoS protection modules include:

    mod_cband mod_bwshare mod_limitipconn mod_evasive

Denial-of-service prevention should be implemented for a web server if such a threat exists. However, specific configuration details are very dependent on the environment and often best left at the discretion of the administrator.

### Use Appropriate Modules to Improve <tt>httpd</tt>'s Security [ref]group

Among the modules available for `httpd` are several whose use may improve the security of the web server installation. This section recommends and discusses the deployment of security-relevant modules.

### Deploy <tt>mod_security</tt> [ref]group

The `security` module provides an application level firewall for `httpd`. Following its installation with the base ruleset, specific configuration advice can be found at http://www.modsecurity.org/ to design a policy that best matches the security needs of the web applications. Usage of `mod_security` is highly recommended for some environments, but it should be noted this module does not ship with Red Hat Enterprise Linux itself, and instead is provided via Extra Packages for Enterprise Linux (EPEL). For more information on EPEL please refer to http://fedoraproject.org/wiki/EPEL.

### Deploy <tt>mod_ssl</tt> [ref]group

Because HTTP is a plain text protocol, all traffic is susceptible to passive monitoring. If there is a need for confidentiality, SSL should be configured and enabled to encrypt content.
Note: `mod_nss` is a FIPS 140-2 certified alternative to `mod_ssl`. The modules share a considerable amount of code and should be nearly identical in functionality. If FIPS 140-2 validation is required, then `mod_nss` should be used. If it provides some feature or its greater compatibility is required, then `mod_ssl` should be used.

### Directory Restrictions [ref]group

The Directory tags in the web server configuration file allow finer grained access control for a specified directory. All web directories should be configured on a case-by-case basis, allowing access only where needed.

### Configure PHP Securely [ref]group

PHP is a widely-used and often misconfigured server-side scripting language. It should be used with caution, but configured appropriately when needed.
Review `/etc/php.ini` and make the following changes if possible:

    # Do not expose PHP error messages to external users
    display_errors = Off

    # Enable safe mode
    safe_mode = On

    # Only allow access to executables in isolated directory
    safe_mode_exec_dir = php-required-executables-path

    # Limit external access to PHP environment
    safe_mode_allowed_env_vars = PHP_

    # Restrict PHP information leakage
    expose_php = Off

    # Log all errors
    log_errors = On

    # Do not register globals for input data
    register_globals = Off

    # Minimize allowable PHP post size
    post_max_size = 1K

    # Ensure PHP redirects appropriately
    cgi.force_redirect = 0

    # Disallow uploading unless necessary
    file_uploads = Off

    # Disallow treatment of file requests as fopen calls
    allow_url_fopen = Off

    # Enable SQL safe mode
    sql.safe_mode = On

### Minimize Web Server Loadable Modules [ref]group

A default installation of `httpd` includes a plethora of dynamically shared objects (DSO) that are loaded at run-time. Unlike the aforementioned compiled-in modules, a DSO can be disabled in the configuration file by removing the corresponding LoadModule directive.
Note: A DSO only provides additional functionality if associated directives are included in the `httpd` configuration file. It should also be noted that removing a DSO will produce errors on `httpd` startup if the configuration file contains directives that apply to that module. Refer to `http://httpd.apache.org/docs/` for details on which directives are associated with each DSO.
Following each DSO removal, the configuration can be tested with the following command to check if everything still works:

    $ sudo service httpd configtest

The purpose of each of the modules loaded by default will now be addressed one at a time. If none of a module's directives are being used, remove it.

### <tt>httpd</tt> Core Modules [ref]group

These modules comprise a basic subset of modules that are likely needed for base `httpd` functionality; ensure they are not commented out in `/etc/httpd/conf/httpd.conf`:

    LoadModule auth_basic_module modules/mod_auth_basic.so
    LoadModule authn_default_module modules/mod_authn_default.so
    LoadModule authz_host_module modules/mod_authz_host.so
    LoadModule authz_user_module modules/mod_authz_user.so
    LoadModule authz_groupfile_module modules/mod_authz_groupfile.so
    LoadModule authz_default_module modules/mod_authz_default.so
    LoadModule log_config_module modules/mod_log_config.so
    LoadModule logio_module modules/mod_logio.so
    LoadModule setenvif_module modules/mod_setenvif.so
    LoadModule mime_module modules/mod_mome.so
    LoadModule autoindex_module modules/mod_autoindex.so
    LoadModule negotiation_module modules/mod_negotiation.so
    LoadModule dir_module modules/mod_dir.so
    LoadModule alias_module modules/mod_alias.so

Minimizing the number of loadable modules available to the web server reduces risk by limiting the capabilities allowed by the web server.

### Minimize Modules for HTTP Basic Authentication [ref]group

The following modules are necessary if this web server will provide content that will be restricted by a password.
Authentication can be performed using local plain text password files (`authn_file`), local DBM password files (`authn_dbm`) or an LDAP directory. The only module required by the web server depends on your choice of authentication. Comment out the modules you don't need from the following:

    LoadModule authn_file_module modules/mod_authn_file.so
    LoadModule authn_dbm_module modules/mod_authn_dbm.so

`authn_alias` allows for authentication based on aliases. `authn_anon` allows anonymous authentication similar to that of anonymous ftp sites. `authz_owner` allows authorization based on file ownership. `authz_dbm` allows for authorization based on group membership if the web server is using DBM authentication.
If the above functionality is unnecessary, comment out the related module:

    #LoadModule authn_alias_module modules/mod_authn_alias.so
    #LoadModule authn_anon_module modules/mod_authn_anon.so
    #LoadModule authz_owner_module modules/mod_authz_owner.so
    #LoadModule authz_dbm_module modules/mod_authz_dbm.so

### Minimize Configuration Files Included [ref]group

The `Include` directive directs `httpd` to load supplementary configuration files from a provided path. The default configuration loads all files that end in `.conf` from the `/etc/httpd/conf.d` directory.
To restrict excess configuration, the following line should be commented out and replaced with `Include` directives that only reference required configuration files:

    #Include conf.d/*.conf

If the above change was made, ensure that the SSL encryption remains loaded by explicitly including the corresponding configuration file:

    Include conf.d/ssl.conf

If PHP is necessary, a similar alteration must be made:

    Include conf.d/php.conf

Explicitly listing the configuration files to be loaded during web server start-up avoids the possibility of unwanted or malicious configuration files to be automatically included as part of the server's running configuration.

### Minimize Various Optional Components [ref]group

The following modules perform very specific tasks, sometimes providing access to just a few additional directives. If such functionality is not required (or if you are not using these directives), comment out the associated module:

- External filtering (response passed through external program prior to client delivery)

      #LoadModule ext_filter_module modules/mod_ext_filter.so

- User-specified Cache Control and Expiration

      #LoadModule expires_module modules/mod_expires.so

- Compression Output Filter (provides content compression prior to client delivery)

      #LoadModule deflate_module modules/mod_deflate.so

- HTTP Response/Request Header Customization

      #LoadModule headers_module modules/mod_headers.so

- User activity monitoring via cookies

      #LoadModule usertrack_module modules/mod_usertrack.so

- Dynamically configured mass virtual hosting

      #LoadModule vhost_alias_module modules/mod_vhost_alias.so

Minimizing the number of loadable modules available to the web server reduces risk by limiting the capabilities allowed by the web server.

### System Security Services Daemon [ref]group

The System Security Services Daemon (SSSD) is a system daemon that provides access to different identity and authentication providers such as Red Hat's IdM, Microsoft's AD, openLDAP, MIT Kerberos, etc. It uses a common framework that can provide caching and offline support to systems utilizing SSSD. SSSD using caching to reduce load on authentication servers permit offline authentication as well as store extended user data.
For more information, see https://access.redhat.com/documentation/en-US/Red_Hat_Enterprise_Linux/6/html/Deployment_Guide/SSSD-Introduction.html

### DHCP [ref]group

The Dynamic Host Configuration Protocol (DHCP) allows systems to request and obtain an IP address and other configuration parameters from a server.
This guide recommends configuring networking on clients by manually editing the appropriate files under `/etc/sysconfig`. Use of DHCP can make client systems vulnerable to compromise by rogue DHCP servers, and should be avoided unless necessary. If using DHCP is necessary, however, there are best practices that should be followed to minimize security risk.

### Disable DHCP Client [ref]group

DHCP is the default network configuration method provided by the system installer, and common on many networks. Nevertheless, manual management of IP addresses for systems implies a greater degree of management and accountability for network activity.

### Disable DHCP Server [ref]group

If the system must act as a DHCP server, the configuration information it serves should be minimized. Also, support for other protocols and DNS-updating schemes should be explicitly disabled unless needed. The configuration file for dhcpd is called `/etc/dhcp/dhcpd.conf`. The file begins with a number of global configuration options. The remainder of the file is divided into sections, one for each block of addresses offered by dhcpd, each of which contains configuration options specific to that address block.

### Disable DHCP Server [ref]group

The DHCP server `dhcpd` is not installed or activated by default. If the software was installed and activated, but the system does not need to act as a DHCP server, it should be disabled and removed.

### Configure DHCP Client if Necessary [ref]group

If DHCP must be used, then certain configuration changes can minimize the amount of information it receives and applies from the network, and thus the amount of incorrect information a rogue DHCP server could successfully distribute. For more information on configuring dhclient, see the `dhclient(8)` and `dhclient.conf(5)` man pages.

### Network Time Protocol [ref]group

The Network Time Protocol is used to manage the system clock over a network. Computer clocks are not very accurate, so time will drift unpredictably on unmanaged systems. Central time protocols can be used both to ensure that time is consistent among a network of systems, and that their time is consistent with the outside world.
If every system on a network reliably reports the same time, then it is much easier to correlate log messages in case of an attack. In addition, a number of cryptographic protocols (such as Kerberos) use timestamps to prevent certain types of attacks. If your network does not have synchronized time, these protocols may be unreliable or even unusable.
Depending on the specifics of the network, global time accuracy may be just as important as local synchronization, or not very important at all. If your network is connected to the Internet, using a public timeserver (or one provided by your enterprise) provides globally accurate timestamps which may be essential in investigating or responding to an attack which originated outside of your network.
A typical network setup involves a small number of internal systems operating as NTP servers, and the remainder obtaining time information from those internal servers.
More information on how to configure the NTP server software, including configuration of cryptographic authentication for time data, is available at http://www.ntp.org.

### Print Support [ref]group

The Common Unix Printing System (CUPS) service provides both local and network printing support. A system running the CUPS service can accept print jobs from other systems, process them, and send them to the appropriate printer. It also provides an interface for remote administration through a web browser. The CUPS service is installed and activated by default. The project homepage and more detailed documentation are available at http://www.cups.org.

### Configure the CUPS Service if Necessary [ref]group

CUPS provides the ability to easily share local printers with other systems over the network. It does this by allowing systems to share lists of available printers. Additionally, each system that runs the CUPS service can potentially act as a print server. Whenever possible, the printer sharing and print server capabilities of CUPS should be limited or disabled. The following recommendations should demonstrate how to do just that.

### SNMP Server [ref]group

The Simple Network Management Protocol allows administrators to monitor the state of network devices, including computers. Older versions of SNMP were well-known for weak security, such as plaintext transmission of the community string (used for authentication) and usage of easily-guessable choices for the community string.

### Configure SNMP Server if Necessary [ref]group

If it is necessary to run the snmpd agent on the system, some best practices should be followed to minimize the security risk from the installation. The multiple security models implemented by SNMP cannot be fully covered here so only the following general configuration advice can be offered:

- use only SNMP version 3 security models and enable the use of authentication and encryption
- write access to the MIB (Management Information Base) should be allowed only if necessary
- all access to the MIB should be restricted following a principle of least privilege
- network access should be limited to the maximum extent possible including restricting to expected network addresses both in the configuration files and in the system firewall rules
- ensure SNMP agents send traps only to, and accept SNMP queries only from, authorized management stations
- ensure that permissions on the `snmpd.conf` configuration file (by default, in `/etc/snmp`) are 640 or more restrictive
- ensure that any MIB files' permissions are also 640 or more restrictive

### Disable SNMP Server if Possible [ref]group

The system includes an SNMP daemon that allows for its remote monitoring, though it not installed by default. If it was installed and activated but is not needed, the software should be disabled and removed.

### Obsolete Services [ref]group

This section discusses a number of network-visible services which have historically caused problems for system security, and for which disabling or severely limiting the service has been the best available guidance for some time. As a result of this, many of these services are not installed as part of Red Hat Enterprise Linux 6 by default.
Organizations which are running these services should switch to more secure equivalents as soon as possible. If it remains absolutely necessary to run one of these services for legacy reasons, care should be taken to restrict the service as much as possible, for instance by configuring host firewall software such as `iptables` to restrict access to the vulnerable service to only those remote hosts which have a known need to use it.

### Rlogin, Rsh, and Rexec [ref]group

The Berkeley r-commands are legacy services which allow cleartext remote access and have an insecure trust model.

### Telnet [ref]group

The telnet protocol does not provide confidentiality or integrity for information transmitted on the network. This includes authentication information such as passwords. Organizations which use telnet should be actively working to migrate to a more secure protocol.

### NIS [ref]group

The Network Information Service (NIS), also known as 'Yellow Pages' (YP), and its successor NIS+ have been made obsolete by Kerberos, LDAP, and other modern centralized authentication services. NIS should not be used because it suffers from security problems inherent in its design, such as inadequate protection of important authentication information.

### TFTP Server [ref]group

TFTP is a lightweight version of the FTP protocol which has traditionally been used to configure networking equipment. However, TFTP provides little security, and modern versions of networking operating systems frequently support configuration via SSH or other more secure protocols. A TFTP server should be run only if no more secure method of supporting existing equipment can be found.

### Xinetd [ref]group

The `xinetd` service acts as a dedicated listener for some network services (mostly, obsolete ones) and can be used to provide access controls and perform some logging. It has been largely obsoleted by other features, and it is not installed by default. The older Inetd service is not even available as part of Red Hat Enterprise Linux 6.

### Chat/Messaging Services [ref]group

The talk software makes it possible for users to send and receive messages across systems through a terminal session.

### Cron and At Daemons [ref]group

The cron and at services are used to allow commands to be executed at a later time. The cron service is required by almost all systems to perform necessary maintenance tasks, while at may or may not be required on a given system. Both daemons should be configured defensively.

### Restrict at and cron to Authorized Users if Necessary [ref]group

The `/etc/cron.allow` and `/etc/at.allow` files contain lists of users who are allowed to use cron and at to delay execution of processes. If these files exist and if the corresponding files `/etc/cron.deny` and `/etc/at.deny` do not exist, then only users listed in the relevant allow files can run the crontab and at commands to submit jobs to be run at scheduled intervals. On many systems, only the system administrator needs the ability to schedule jobs. Note that even if a given user is not listed in `cron.allow`, cron jobs can still be run as that user. The `cron.allow` file controls only administrative access to the crontab command for scheduling and modifying cron jobs.
To restrict at and cron to only authorized users:

- Remove the cron.deny file:

      $ sudo rm /etc/cron.deny

- Edit `/etc/cron.allow`, adding one line for each user allowed to use the crontab command to create cron jobs.
- Remove the `at.deny` file:

      $ sudo rm /etc/at.deny

- Edit `/etc/at.allow`, adding one line for each user allowed to use the at command to create at jobs.

### NFS and RPC [ref]group

The Network File System is a popular distributed filesystem for the Unix environment, and is very widely deployed. This section discusses the circumstances under which it is possible to disable NFS and its dependencies, and then details steps which should be taken to secure NFS's configuration. This section is relevant to systems operating as NFS clients, as well as to those operating as NFS servers.

### Configure NFS Servers [ref]group

The steps in this section are appropriate for systems which operate as NFS servers.

### Export Filesystems Read-Only if Possible [ref]group

If a filesystem is being exported so that users can view the files in a convenient fashion, but there is no need for users to edit those files, exporting the filesystem read-only removes an attack vector against the server. The default filesystem export mode is `ro`, so do not specify `rw` without a good reason.

### Configure the Exports File Restrictively [ref]group

Linux's NFS implementation uses the file `/etc/exports` to control what filesystems and directories may be accessed via NFS. (See the `exports(5)` manpage for more information about the format of this file.)
The syntax of the `exports` file is not necessarily checked fully on reload, and syntax errors can leave your NFS configuration more open than intended. Therefore, exercise caution when modifying the file.
The syntax of each line in `/etc/exports` is:

    /DIR	host1(opt1,opt2) host2(opt3)

where `/DIR` is a directory or filesystem to export, `hostN` is an IP address, netblock, hostname, domain, or netgroup to which to export, and `optN` is an option.

### Use Access Lists to Enforce Authorization Restrictions [ref]group

When configuring NFS exports, ensure that each export line in `/etc/exports` contains a list of hosts which are allowed to access that export. If no hosts are specified on an export line, then that export is available to any remote host which requests it. All lines of the exports file should specify the hosts (or subnets, if needed) which are allowed to access the exported directory, so that unknown or remote hosts will be denied.
Authorized hosts can be specified in several different formats:

- Name or alias that is recognized by the resolver
- Fully qualified domain name
- IP address
- IP subnets in the format `address/netmask` or `address/CIDR`

### Disable All NFS Services if Possible [ref]group

If there is not a reason for the system to operate as either an NFS client or an NFS server, follow all instructions in this section to disable subsystems required by NFS.

### Disable Services Used Only by NFS [ref]group

If NFS is not needed, disable the NFS client daemons nfslock, rpcgssd, and rpcidmapd.
All of these daemons run with elevated privileges, and many listen for network connections. If they are not needed, they should be disabled to improve system security posture.

### Disable netfs if Possible [ref]group

To determine if any network filesystems handled by netfs are currently mounted on the system execute the following command:

    $ mount -t nfs,nfs4,smbfs,cifs,ncpfs

If the command did not return any output then disable netfs.

### Configure All Systems which Use NFS [ref]group

The steps in this section are appropriate for all systems which run NFS, whether they operate as clients or as servers.

### Configure NFS Services to Use Fixed Ports (NFSv3 and NFSv2) [ref]group

Firewalling should be done at each host and at the border firewalls to protect the NFS daemons from remote access, since NFS servers should never be accessible from outside the organization. However, by default for NFSv3 and NFSv2, the RPC Bind service assigns each NFS service to a port dynamically at service startup time. Dynamic ports cannot be protected by port filtering firewalls such as iptables.
Therefore, restrict each service to always use a given port, so that firewalling can be done effectively. Note that, because of the way RPC is implemented, it is not possible to disable the RPC Bind service even if ports are assigned statically to all RPC services.
In NFSv4, the mounting and locking protocols have been incorporated into the protocol, and the server listens on the the well-known TCP port 2049. As such, NFSv4 does not need to interact with the `rpcbind, lockd, and rpc.statd` daemons, which can and should be disabled in a pure NFSv4 environment. The `rpc.mountd` daemon is still required on the NFS server to setup exports, but is not involved in any over-the-wire operations.

### Make Each System a Client or a Server, not Both [ref]group

If NFS must be used, it should be deployed in the simplest configuration possible to avoid maintainability problems which may lead to unnecessary security exposure. Due to the reliability and security problems caused by NFS (specially NFSv3 and NFSv2), it is not a good idea for systems which act as NFS servers to also mount filesystems via NFS. At the least, crossed mounts (the situation in which each of two servers mounts a filesystem from the other) should never be used.

### Configure NFS Clients [ref]group

The steps in this section are appropriate for systems which operate as NFS clients.

### Mount Remote Filesystems with Restrictive Options [ref]group

Edit the file `/etc/fstab`. For each filesystem whose type (column 3) is `nfs` or `nfs4`, add the text `,nodev,nosuid` to the list of mount options in column 4. If appropriate, also add `,noexec`.
See the section titled "Restrict Partition Mount Options" for a description of the effects of these options. In general, execution of files mounted via NFS should be considered risky because of the possibility that an adversary could intercept the request and substitute a malicious file. Allowing setuid files to be executed from remote servers is particularly risky, both for this reason and because it requires the clients to extend root-level trust to the NFS server.

### Disable NFS Server Daemons [ref]group

There is no need to run the NFS server daemons `nfs` and `rpcsvcgssd` except on a small number of properly secured systems designated as NFS servers. Ensure that these daemons are turned off on clients.

### Base Services [ref]group

This section addresses the base services that are installed on a Red Hat Enterprise Linux 6 default installation which are not covered in other sections. Some of these services listen on the network and should be treated with particular discretion. Other services are local system utilities that may or may not be extraneous. In general, system services should be disabled if not required.

### SSH Server [ref]group

The SSH protocol is recommended for remote login and remote file transfer. SSH provides confidentiality and integrity for data exchanged between two systems, as well as server authentication, through the use of public key cryptography. The implementation included with the system is called OpenSSH, and more detailed documentation is available from its website, http://www.openssh.org. Its server program is called `sshd` and provided by the RPM package `openssh-server`.

### Configure OpenSSH Server if Necessary [ref]group

If the system needs to act as an SSH server, then certain changes should be made to the OpenSSH daemon configuration file `/etc/ssh/sshd_config`. The following recommendations can be applied to this file. See the `sshd_config(5)` man page for more detailed information.

### Strengthen Firewall Configuration if Possible [ref]group

If the SSH server is expected to only receive connections from the local network, then strengthen the default firewall rule for the SSH service to only accept connections from the appropriate network segment(s).
Determine an appropriate network block, `netwk`, and network mask, `mask`, representing the systems on your network which will be allowed to access this SSH server.
Edit the files `etc/sysconfig/iptables` and `/etc/sysconfig/ip6tables` (if IPv6 is in use). In each file, locate the line:

    -A INPUT -m state --state NEW -m tcp -p tcp --dport 22 -j ACCEPT

and replace it with:

    -A INPUT -s netwk/mask -m state --state NEW -p tcp --dport 22 -j ACCEPT

### DNS Server [ref]group

Most organizations have an operational need to run at least one nameserver. However, there are many common attacks involving DNS server software, and this server software should be disabled on any system on which it is not needed.

### Protect DNS Data from Tampering or Attack [ref]group

This section discusses DNS configuration options which make it more difficult for attackers to gain access to private DNS data or to modify DNS data.

### Run Separate DNS Servers for External and Internal Queries [ref]group

Is it possible to run external and internal nameservers on separate machines? If so, follow the configuration guidance in this section. On the external nameserver, edit `/etc/named.conf` to add or correct the following directives:

    options {
      allow-query { any; };
      recursion no;
      ...
    };
    zone "example.com " IN {
      ...
    };

On the internal nameserver, edit `/etc/named.conf`. Add or correct the following directives, where SUBNET is the numerical IP representation of your organization in the form xxx.xxx.xxx.xxx/xx:

    acl internal {
      SUBNET ;
      localhost;
    };
    options {
      allow-query { internal; };
      ...
    };
    zone "internal.example.com " IN {
      ...
    };

### Use Views to Partition External and Internal Information [ref]group

If it is not possible to run external and internal nameservers on separate physical machines, run BIND9 and simulate this feature using views. Edit `/etc/named.conf`. Add or correct the following directives (where SUBNET is the numerical IP representation of your organization in the form xxx.xxx.xxx.xxx/xx):

    acl internal {
      SUBNET ;
      localhost;
    };
    view "internal-view" {
      match-clients { internal; };
      zone "." IN {
        type hint;
        file "db.cache";
      };
      zone "internal.example.com " IN {
        ...
      };
    };

    view "external-view" {
      match-clients { any; };
      recursion no;
      zone "example.com " IN {
        ...
      };
    };

### Isolate DNS from Other Services [ref]group

This section discusses mechanisms for preventing the DNS server from interfering with other services. This is done both to protect the remainder of the network should a nameserver be compromised, and to make direct attacks on nameservers more difficult.

### Run DNS Software in a chroot Jail [ref]group

Install the `bind-chroot` package:

    $ sudo yum install bind-chroot

Place a valid named.conf file inside the chroot jail:

    $ sudo cp /etc/named.conf /var/named/chroot/etc/named.conf
    $ sudo chown root:root /var/named/chroot/etc/named.conf
    $ sudo chmod 644 /var/named/chroot/etc/named.conf

Create and populate an appropriate zone directory within the jail, based on the options directive. If your `named.conf` includes:

    options {
    directory "/path/to/DIRNAME ";
    ...
    }

then copy that directory and its contents from the original zone directory:

    $ sudo cp -r /path/to/DIRNAME /var/named/chroot/DIRNAME

Add or correct the following line within `/etc/sysconfig/named`:

    ROOTDIR=/var/named/chroot

### Run DNS Software on Dedicated Servers [ref]group

Since DNS is a high-risk service which must frequently be made available to the entire Internet, it is strongly recommended that no other services be offered by machines which act as organizational DNS servers.

### Disable DNS Server [ref]group

DNS software should be disabled on any machine which does not need to be a nameserver. Note that the BIND DNS server software is not installed on Red Hat Enterprise Linux 6 by default. The remainder of this section discusses secure configuration of machines which must be nameservers.

### LDAP [ref]group

LDAP is a popular directory service, that is, a standardized way of looking up information from a central database. Red Hat Enterprise Linux 6 includes software that enables a system to act as both an LDAP client and server.

### Configure OpenLDAP Server [ref]group

This section details some security-relevant settings for an OpenLDAP server. Installation and configuration of OpenLDAP on Red Hat Enterprise Linux 6 is available at: https://access.redhat.com/site/documentation/en-US/Red_Hat_Enterprise_Linux/6/html/Deployment_Guide/ch-Directory_Servers.html.

### Install and Protect LDAP Certificate Files [ref]group

Create the PKI directory for LDAP certificates if it does not already exist:

    $ sudo mkdir /etc/pki/tls/ldap
    $ sudo chown root:root /etc/pki/tls/ldap
    $ sudo chmod 755 /etc/pki/tls/ldap

Using removable media or some other secure transmission format, install the certificate files onto the LDAP server:

- `/etc/pki/tls/ldap/serverkey.pem`: the private key `ldapserverkey.pem`
- `/etc/pki/tls/ldap/servercert.pem`: the certificate file `ldapservercert.pem`

Verify the ownership and permissions of these files:

    $ sudo chown root:ldap /etc/pki/tls/ldap/serverkey.pem
    $ sudo chown root:ldap /etc/pki/tls/ldap/servercert.pem
    $ sudo chmod 640 /etc/pki/tls/ldap/serverkey.pem
    $ sudo chmod 640 /etc/pki/tls/ldap/servercert.pem

Verify that the CA's public certificate file has been installed as `/etc/pki/tls/CA/cacert.pem`, and has the correct permissions:

    $ sudo mkdir /etc/pki/tls/CA
    $ sudo chown root:root /etc/pki/tls/CA/cacert.pem
    $ sudo chmod 644 /etc/pki/tls/CA/cacert.pem

As a result of these steps, the LDAP server will have access to its own private certificate and the key with which that certificate is encrypted, and to the public certificate file belonging to the CA. Note that it would be possible for the key to be protected further, so that processes running as ldap could not read it. If this were done, the LDAP server process would need to be restarted manually whenever the server rebooted.

### Configure OpenLDAP Clients [ref]group

This section provides information on which security settings are important to configure in OpenLDAP clients by manually editing the appropriate configuration files. Red Hat Enterprise Linux 6 provides an automated configuration tool called authconfig and a graphical wrapper for authconfig called `system-config-authentication`. However, these tools do not provide as much control over configuration as manual editing of configuration files. The authconfig tools do not allow you to specify locations of SSL certificate files, which is useful when trying to use SSL cleanly across several protocols. Installation and configuration of OpenLDAP on Red Hat Enterprise Linux 6 is available at https://access.redhat.com/site/documentation/en-US/Red_Hat_Enterprise_Linux/6/html/Deployment_Guide/ch-Directory_Servers.html.

### Mail Server Software [ref]group

Mail servers are used to send and receive email over the network. Mail is a very common service, and Mail Transfer Agents (MTAs) are obvious targets of network attack. Ensure that systems are not running MTAs unnecessarily, and configure needed MTAs as defensively as possible.
Very few systems at any site should be configured to directly receive email over the network. Users should instead use mail client programs to retrieve email from a central server that supports protocols such as IMAP or POP3. However, it is normal for most systems to be independently capable of sending email, for instance so that cron jobs can report output to an administrator. Most MTAs, including Postfix, support a submission-only mode in which mail can be sent from the local system to a central site MTA (or directly delivered to a local account), but the system still cannot receive mail directly over a network.
The `alternatives` program in Red Hat Enterprise Linux permits selection of other mail server software (such as Sendmail), but Postfix is the default and is preferred. Postfix was coded with security in mind and can also be more effectively contained by SELinux as its modular design has resulted in separate processes performing specific actions. More information is available on its website, http://www.postfix.org.

### Configure SMTP For Mail Clients [ref]group

This section discusses settings for Postfix in a submission-only e-mail configuration.

### Configure Operating System to Protect Mail Server [ref]group

The guidance in this section is appropriate for any host which is operating as a site MTA, whether the mail server runs using Sendmail, Postfix, or some other software.

### Configure SSL Certificates for Use with SMTP AUTH [ref]group

If SMTP AUTH is to be used, the use of SSL to protect credentials in transit is strongly recommended. There are also configurations for which it may be desirable to encrypt all mail in transit from one MTA to another, though such configurations are beyond the scope of this guide. In either event, the steps for creating and installing an SSL certificate are independent of the MTA in use, and are described here.

### Ensure Security of Postfix SSL Certificate [ref]group

Create the PKI directory for mail certificates, if it does not already exist:

    $ sudo mkdir /etc/pki/tls/mail
    $ sudo chown root:root /etc/pki/tls/mail
    $ sudo chmod 755 /etc/pki/tls/mail

Using removable media or some other secure transmission format, install the files generated in the previous step onto the mail server:

    /etc/pki/tls/mail/serverkey.pem: the private key mailserverkey.pem
    /etc/pki/tls/mail/servercert.pem: the certificate file mailservercert.pem

Verify the ownership and permissions of these files:

    $ sudo chown root:root /etc/pki/tls/mail/serverkey.pem
    $ sudo chown root:root /etc/pki/tls/mail/servercert.pem
    $ sudo chmod 600 /etc/pki/tls/mail/serverkey.pem
    $ sudo chmod 644 /etc/pki/tls/mail/servercert.pem

Verify that the CA's public certificate file has been installed as `/etc/pki/tls/CA/cacert.pem`, and has the correct permissions:

    $ sudo chown root:root /etc/pki/tls/CA/cacert.pem
    $ sudo chmod 644 /etc/pki/tls/CA/cacert.pem

### Configure Postfix if Necessary [ref]group

Postfix stores its configuration files in the directory /etc/postfix by default. The primary configuration file is `/etc/postfix/main.cf`.

### Control Mail Relaying [ref]group

Postfix's mail relay controls are implemented with the help of the smtpd recipient restrictions option, which controls the restrictions placed on the SMTP dialogue once the sender and recipient envelope addresses are known. The guidance in the following sections should be applied to all systems. If there are systems which must be allowed to relay mail, but which cannot be trusted to relay unconditionally, configure SMTP AUTH with SSL support.

### Configure Trusted Networks and Hosts [ref]group

Edit `/etc/postfix/main.cf`, and configure the contents of the `mynetworks` variable in one of the following ways:

- If any system in the subnet containing the MTA may be trusted to relay messages, add or correct the following line:

      mynetworks_style = subnet

  This is also the default setting, and is in effect if all `my_networks_style` directives are commented.
- If only the MTA host itself is trusted to relay messages, add or correct the following line:

      mynetworks_style = host

- If the set of systems which can relay is more complicated, manually specify an entry for each netblock or IP address which is trusted to relay by setting the `mynetworks` variable directly:

      mynetworks = 10.0.0.0/16, 192.168.1.0/24, 127.0.0.1

### Use TLS for SMTP AUTH [ref]group

Postfix provides options to use TLS for certificate-based authentication and encrypted sessions. An encrypted session protects the information that is transmitted with SMTP mail or with SASL authentication. To configure Postfix to protect all SMTP AUTH transactions using TLS, see http://www.postfix.org/TLS_README.html.

### Enact SMTP Relay Restrictions [ref]group

To configure Postfix to restrict addresses to which it will send mail, see: http://www.postfix.org/SMTPD_ACCESS_README.html#danger
The full contents of `smtpd_recipient_restrictions` will vary by site, since this is a common place to put spam restrictions and other site-specific options. The `permit_mynetworks` option allows all mail to be relayed from the systems in `mynetworks`. Then, the `reject_unauth_destination` option denies all mail whose destination address is not local, preventing any other systems from relaying. These two options should always appear in this order, and should usually follow one another immediately unless SMTP AUTH is used.

### Enact SMTP Recipient Restrictions [ref]group

To configure Postfix to restrict addresses to which it will send mail, see: http://www.postfix.org/SMTPD_ACCESS_README.html#danger
The full contents of `smtpd_recipient_restrictions` will vary by site, since this is a common place to put spam restrictions and other site-specific options. The `permit_mynetworks` option allows all mail to be relayed from the systems in `mynetworks`. Then, the `reject_unauth_destination` option denies all mail whose destination address is not local, preventing any other systems from relaying. These two options should always appear in this order, and should usually follow one another immediately unless SMTP AUTH is used.

### Require SMTP AUTH Before Relaying from Untrusted Clients [ref]group

SMTP authentication allows remote clients to relay mail safely by requiring them to authenticate before submitting mail. Postfix's SMTP AUTH uses an authentication library called SASL, which is not part of Postfix itself. To enable the use of SASL authentication, see http://www.postfix.org/SASL_README.html

### Configure Postfix Resource Usage to Limit Denial of Service Attacks [ref]group

Edit `/etc/postfix/main.cf`. Edit the following lines to configure the amount of system resources Postfix can consume:

    default_process_limit = 100
    smtpd_client_connection_count_limit = 10
    smtpd_client_connection_rate_limit = 30
    queue_minfree = 20971520
    header_size_limit = 51200
    message_size_limit = 10485760
    smtpd_recipient_limit = 100

The values here are examples.

### Avahi Server [ref]group

The Avahi daemon implements the DNS Service Discovery and Multicast DNS protocols, which provide service and host discovery on a network. It allows a system to automatically identify resources on the network, such as printers or web servers. This capability is also known as mDNSresponder and is a major part of Zeroconf networking.

### Disable Avahi Server if Possible [ref]group

Because the Avahi daemon service keeps an open network port, it is subject to network attacks. Disabling it can reduce the system's vulnerability to such attacks.

### Configure Avahi if Necessary [ref]group

If your system requires the Avahi daemon, its configuration can be restricted to improve security. The Avahi daemon configuration file is `/etc/avahi/avahi-daemon.conf`. The following security recommendations should be applied to this file: See the `avahi-daemon.conf(5)` man page, or documentation at http://www.avahi.org, for more detailed information about the configuration options.

### X Window System [ref]group

The X Window System implementation included with the system is called X.org.

### Disable X Windows [ref]group

Unless there is a mission-critical reason for the system to run a graphical user interface, ensure X is not set to start automatically at boot and remove the X Windows software packages. There is usually no reason to run X Windows on a dedicated server system, as it increases the system's attack surface and consumes system resources. Administrators of server systems should instead login via SSH or on the text console.

### IMAP and POP3 Server [ref]group

Dovecot provides IMAP and POP3 services. It is not installed by default. The project page at http://www.dovecot.org contains more detailed information about Dovecot configuration.

### Configure Dovecot if Necessary [ref]group

If the system will operate as an IMAP or POP3 server, the dovecot software should be configured securely by following the recommendations below.

### Enable SSL Support [ref]group

SSL should be used to encrypt network traffic between the Dovecot server and its clients. Users must authenticate to the Dovecot server in order to read their mail, and passwords should never be transmitted in clear text. In addition, protecting mail as it is downloaded is a privacy measure, and clients may use SSL certificates to authenticate the server, preventing another system from impersonating the server.

### Allow IMAP Clients to Access the Server [ref]group

The default iptables configuration does not allow inbound access to any services. This modification will allow remote hosts to initiate connections to the IMAP daemon, while keeping all other ports on the server in their default protected state. To configure `iptables` to allow port 143 traffic one must edit `/etc/sysconfig/iptables` and `/etc/sysconfig/ip6tables` (if IPv6 is in use). Add the following line, ensuring that it appears before the final LOG and DROP lines for the INPUT chain:

    -A INPUT -m state --state NEW -p tcp --dport 143 -j ACCEPT

### Support Only the Necessary Protocols [ref]group

Dovecot supports the IMAP and POP3 protocols, as well as SSL-protected versions of those protocols. Configure the Dovecot server to support only the protocols needed by your site. Edit `/etc/dovecot/dovecot.conf`. Add or correct the following lines, replacing `PROTOCOL` with only the subset of protocols (`imap`, `imaps`, `pop3`, `pop3s`) required:

    protocols = PROTOCOL

If possible, require SSL protection for all transactions. The SSL protocol variants listen on alternate ports (995 instead of 110 for pop3s, and 993 instead of 143 for imaps), and require SSL-aware clients. An alternate approach is to listen on the standard port and require the client to use the STARTTLS command before authenticating.

### Disable Dovecot [ref]group

If the system does not need to operate as an IMAP or POP3 server, the dovecot software should be disabled and removed.

### Samba(SMB) Microsoft Windows File Sharing Server [ref]group

When properly configured, the Samba service allows Linux systems to provide file and print sharing to Microsoft Windows systems. There are two software packages that provide Samba support. The first, `samba-client`, provides a series of command line tools that enable a client system to access Samba shares. The second, simply labeled `samba`, provides the Samba service. It is this second package that allows a Linux system to act as an Active Directory server, a domain controller, or as a domain member. Only the `samba-client` package is installed by default.

### Disable Samba if Possible [ref]group

Even after the Samba server package has been installed, it will remain disabled. Do not enable this service unless it is absolutely necessary to provide Microsoft Windows file and print sharing functionality.

### Configure Samba if Necessary [ref]group

All settings for the Samba daemon can be found in `/etc/samba/smb.conf`. Settings are divided between a `[global]` configuration section and a series of user created share definition sections meant to describe file or print shares on the system. By default, Samba will operate in user mode and allow client systems to access local home directories and printers. It is recommended that these settings be changed or that additional limitations be set in place.

### Restrict Printer Sharing [ref]group

By default, Samba utilizes the CUPS printing service to enable printer sharing with Microsoft Windows workstations. If there are no printers on the local system, or if printer sharing with Microsoft Windows is not required, disable the printer sharing capability by commenting out the following lines, found in `/etc/samba/smb.conf`:

    [global]
      load printers = yes
      cups options = raw
    [printers]
      comment = All Printers
      path = /usr/spool/samba
      browseable = no
      guest ok = no
      writable = no
      printable = yes

There may be other options present, but these are the only options enabled and uncommented by default. Removing the `[printers]` share should be enough for most users. If the Samba printer sharing capability is needed, consider disabling the Samba network browsing capability or restricting access to a particular set of users or network addresses. Set the `valid users` parameter to a small subset of users or restrict it to a particular group of users with the shorthand `@`. Separate each user or group of users with a space. For example, under the `[printers]` share:

    [printers]
      valid users = user @printerusers

### Restrict SMB File Sharing to Configured Networks [ref]group

Only users with local user accounts will be able to log in to Samba shares by default. Shares can be limited to particular users or network addresses. Use the `hosts allow` and `hosts deny` directives accordingly, and consider setting the valid users directive to a limited subset of users or to a group of users. Separate each address, user, or user group with a space as follows for a particular share or global:

    [share]
      hosts allow = 192.168.1. 127.0.0.1
      valid users = userone usertwo @usergroup

It is also possible to limit read and write access to particular users with the read list and write list options, though the permissions set by the system itself will override these settings. Set the read only attribute for each share to ensure that global settings will not accidentally override the individual share settings. Then, as with the valid users directive, separate each user or group of users with a space:

    [share]
      read only = yes
      write list = userone usertwo @usergroup

### Proxy Server [ref]group

A proxy server is a very desirable target for a potential adversary because much (or all) sensitive data for a given infrastructure may flow through it. Therefore, if one is required, the system acting as a proxy server should be dedicated to that purpose alone and be stored in a physically secure location. The system's default proxy server software is Squid, and provided in an RPM package of the same name.

### Disable Squid if Possible [ref]group

If Squid was installed and activated, but the system does not need to act as a proxy server, then it should be disabled and removed.

### System Settings [ref]group

Contains rules that check correct system settings.

### Configure Syslog [ref]group

The syslog service has been the default Unix logging mechanism for many years. It has a number of downsides, including inconsistent log format, lack of authentication for received messages, and lack of authentication, encryption, or reliable transport for messages sent over a network. However, due to its long history, syslog is a de facto standard which is supported by almost all Unix applications.
In Red Hat Enterprise Linux 6, rsyslog has replaced ksyslogd as the syslog daemon of choice, and it includes some additional security features such as reliable, connection-oriented (i.e. TCP) transmission of logs, the option to log to database formats, and the encryption of log data en route to a central logging server. This section discusses how to configure rsyslog for best effect, and how to use tools provided with the system to maintain and monitor logs.

### Rsyslog Logs Sent To Remote Host [ref]group

If system logs are to be useful in detecting malicious activities, it is necessary to send logs to a remote server. An intruder who has compromised the root account on a machine may delete the log entries which indicate that the system was attacked before they are seen by an administrator.
However, it is recommended that logs be stored on the local host in addition to being sent to the loghost, especially if `rsyslog` has been configured to use the UDP protocol to send messages over a network. UDP does not guarantee reliable delivery, and moderately busy sites will lose log messages occasionally, especially in periods of high traffic which may be the result of an attack. In addition, remote `rsyslog` messages are not authenticated in any way by default, so it is easy for an attacker to introduce spurious messages to the central log server. Also, some problems cause loss of network connectivity, which will prevent the sending of messages to the central server. For all of these reasons, it is better to store log messages both centrally and on each host, so that they can be correlated if necessary.

### Ensure Proper Configuration of Log Files [ref]group

The file `/etc/rsyslog.conf` controls where log message are written. These are controlled by lines called rules, which consist of a selector and an action. These rules are often customized depending on the role of the system, the requirements of the environment, and whatever may enable the administrator to most effectively make use of log data. The default rules in Red Hat Enterprise Linux 6 are:

    *.info;mail.none;authpriv.none;cron.none                /var/log/messages
    authpriv.*                                              /var/log/secure
    mail.*                                                  -/var/log/maillog
    cron.*                                                  /var/log/cron
    *.emerg                                                 *
    uucp,news.crit                                          /var/log/spooler
    local7.*                                                /var/log/boot.log

See the man page `rsyslog.conf(5)` for more information. Note that the `rsyslog` daemon can be configured to use a timestamp format that some log processing programs may not understand. If this occurs, edit the file `/etc/rsyslog.conf` and add or edit the following line:

    $ ActionFileDefaultTemplate RSYSLOG_TraditionalFileFormat

### Configure <tt>rsyslogd</tt> to Accept Remote Messages If Acting as a Log Server [ref]group

By default, `rsyslog` does not listen over the network for log messages. If needed, modules can be enabled to allow the rsyslog daemon to receive messages from other systems and for the system thus to act as a log server. If the machine is not a log server, then lines concerning these modules should remain commented out.

### Configure Logwatch on the Central Log Server [ref]group

Is this machine the central log server? If so, edit the file `/etc/logwatch/conf/logwatch.conf` as shown below.

### Ensure All Logs are Rotated by <tt>logrotate</tt> [ref]group

Edit the file `/etc/logrotate.d/syslog`. Find the first line, which should look like this (wrapped for clarity):

    /var/log/messages /var/log/secure /var/log/maillog /var/log/spooler \
      /var/log/boot.log /var/log/cron {

Edit this line so that it contains a one-space-separated listing of each log file referenced in `/etc/rsyslog.conf`.
All logs in use on a system must be rotated regularly, or the log files will consume disk space over time, eventually interfering with system operation. The file `/etc/logrotate.d/syslog` is the configuration file used by the `logrotate` program to maintain all log files written by `syslog`. By default, it rotates logs weekly and stores four archival copies of each log. These settings can be modified by editing `/etc/logrotate.conf`, but the defaults are sufficient for purposes of this guide.
Note that `logrotate` is run nightly by the cron job `/etc/cron.daily/logrotate`. If particularly active logs need to be rotated more often than once a day, some other mechanism must be used.

### Network Configuration and Firewalls [ref]group

Most machines must be connected to a network of some sort, and this brings with it the substantial risk of network attack. This section discusses the security impact of decisions about networking which must be made when configuring a system.
This section also discusses firewalls, network access controls, and other network security frameworks, which allow system-level rules to be written that can limit an attackers' ability to connect to your system. These rules can specify that network traffic should be allowed or denied from certain IP addresses, hosts, and networks. The rules can also specify which of the system's network services are available to particular hosts or networks.

### IPSec Support [ref]group

Support for Internet Protocol Security (IPsec) is provided in Red Hat Enterprise Linux 6 with openswan and libreswan packages respectively.

### iptables and ip6tables [ref]group

A host-based firewall called `netfilter` is included as part of the Linux kernel distributed with the system. It is activated by default. This firewall is controlled by the program `iptables`, and the entire capability is frequently referred to by this name. An analogous program called `ip6tables` handles filtering for IPv6.
Unlike TCP Wrappers, which depends on the network server program to support and respect the rules written, `netfilter` filtering occurs at the kernel level, before a program can even process the data from the network packet. As such, any program on the system is affected by the rules written.
This section provides basic information about strengthening the `iptables` and `ip6tables` configurations included with the system. For more complete information that may allow the construction of a sophisticated ruleset tailored to your environment, please consult the references at the end of this section.

### Strengthen the Default Ruleset [ref]group

The default rules can be strengthened. The system scripts that activate the firewall rules expect them to be defined in the configuration files `iptables` and `ip6tables` in the directory `/etc/sysconfig`. Many of the lines in these files are similar to the command line arguments that would be provided to the programs `/sbin/iptables` or `/sbin/ip6tables` - but some are quite different.
The following recommendations describe how to strengthen the default ruleset configuration file. An alternative to editing this configuration file is to create a shell script that makes calls to the iptables program to load in rules, and then invokes service iptables save to write those loaded rules to `/etc/sysconfig/iptables.`
The following alterations can be made directly to `/etc/sysconfig/iptables` and `/etc/sysconfig/ip6tables`. Instructions apply to both unless otherwise noted. Language and address conventions for regular iptables are used throughout this section; configuration for ip6tables will be either analogous or explicitly covered.

### Restrict ICMP Message Types [ref]group

In `/etc/sysconfig/iptables`, the accepted ICMP messages types can be restricted. To accept only ICMP echo reply, destination unreachable, and time exceeded messages, remove the line:

    -A INPUT -p icmp --icmp-type any -j ACCEPT

and insert the lines:

    -A INPUT -p icmp --icmp-type echo-reply -j ACCEPT
    -A INPUT -p icmp --icmp-type destination-unreachable -j ACCEPT
    -A INPUT -p icmp --icmp-type time-exceeded -j ACCEPT

To allow the system to respond to pings, also insert the following line:

    -A INPUT -p icmp --icmp-type echo-request -j ACCEPT

Ping responses can also be limited to certain networks or hosts by using the -s option in the previous rule. Because IPv6 depends so heavily on ICMPv6, it is preferable to deny the ICMPv6 packets you know you don't need (e.g. ping requests) in `/etc/sysconfig/ip6tables`, while letting everything else through:

    -A INPUT -p icmpv6 --icmpv6-type echo-request -j DROP

If you are going to statically configure the system's address, it should ignore Router Advertisements which could add another IPv6 address to the interface or alter important network settings:

    -A INPUT -p icmpv6 --icmpv6-type router-advertisement -j DROP

Restricting ICMPv6 message types in `/etc/sysconfig/ip6tables` is not recommended because the operation of IPv6 depends heavily on ICMPv6. Thus, great care must be taken if any other ICMPv6 types are blocked.

### Log and Drop Packets with Suspicious Source Addresses [ref]group

Packets with non-routable source addresses should be rejected, as they may indicate spoofing. Because the modified policy will reject non-matching packets, you only need to add these rules if you are interested in also logging these spoofing or suspicious attempts before they are dropped. If you do choose to log various suspicious traffic, add identical rules with a target of `DROP` after each LOG. To log and then drop these IPv4 packets, insert the following rules in `/etc/sysconfig/iptables` (excepting any that are intentionally used):

    -A INPUT -s 10.0.0.0/8 -j LOG --log-prefix "IP DROP SPOOF A: "
    -A INPUT -s 172.16.0.0/12 -j LOG --log-prefix "IP DROP SPOOF B: "
    -A INPUT -s 192.168.0.0/16 -j LOG --log-prefix "IP DROP SPOOF C: "
    -A INPUT -s 224.0.0.0/4 -j LOG --log-prefix "IP DROP MULTICAST D: "
    -A INPUT -s 240.0.0.0/5 -j LOG --log-prefix "IP DROP SPOOF E: "
    -A INPUT -d 127.0.0.0/8 -j LOG --log-prefix "IP DROP LOOPBACK: "

Similarly, you might wish to log packets containing some IPv6 reserved addresses if they are not expected on your network:

    -A INPUT -i eth0 -s ::1 -j LOG --log-prefix "IPv6 DROP LOOPBACK: "
    -A INPUT -s 2002:E000::/20 -j LOG --log-prefix "IPv6 6to4 TRAFFIC: "
    -A INPUT -s 2002:7F00::/24 -j LOG --log-prefix "IPv6 6to4 TRAFFIC: "
    -A INPUT -s 2002:0000::/24 -j LOG --log-prefix "IPv6 6to4 TRAFFIC: "
    -A INPUT -s 2002:FF00::/24 -j LOG --log-prefix "IPv6 6to4 TRAFFIC: "
    -A INPUT -s 2002:0A00::/24 -j LOG --log-prefix "IPv6 6to4 TRAFFIC: "
    -A INPUT -s 2002:AC10::/28 -j LOG --log-prefix "IPv6 6to4 TRAFFIC: "
    -A INPUT -s 2002:C0A8::/32 -j LOG --log-prefix "IPv6 6to4 TRAFFIC: "

If you are not expecting to see site-local multicast or auto-tunneled traffic, you can log those:

    -A INPUT -s FF05::/16 -j LOG --log-prefix "IPv6 SITE-LOCAL MULTICAST: "
    -A INPUT -s ::0.0.0.0/96 -j LOG --log-prefix "IPv4 COMPATIBLE IPv6 ADDR: "

If you wish to block multicasts to all link-local nodes (e.g. if you are not using router auto-configuration and do not plan to have any services that multicast to the entire local network), you can block the link-local all-nodes multicast address (before accepting incoming ICMPv6):

    -A INPUT -d FF02::1 -j LOG --log-prefix "Link-local All-Nodes Multicast: "

However, if you're going to allow IPv4 compatible IPv6 addresses (of the form ::0.0.0.0/96), you should then consider logging the non-routable IPv4-compatible addresses:

    -A INPUT -s ::0.0.0.0/104 -j LOG --log-prefix "IP NON-ROUTABLE ADDR: "
    -A INPUT -s ::127.0.0.0/104 -j LOG --log-prefix "IP DROP LOOPBACK: "
    -A INPUT -s ::224.0.0.0.0/100 -j LOG --log-prefix "IP DROP MULTICAST D: "
    -A INPUT -s ::255.0.0.0/104 -j LOG --log-prefix "IP BROADCAST: "

If you are not expecting to see any IPv4 (or IPv4-compatible) traffic on your network, consider logging it before it gets dropped:

    -A INPUT -s ::FFFF:0.0.0.0/96 -j LOG --log-prefix "IPv4 MAPPED IPv6 ADDR: "
    -A INPUT -s 2002::/16 -j LOG --log-prefix "IPv6 6to4 ADDR: "

The following rule will log all traffic originating from a site-local address, which is deprecated address space:

    -A INPUT -s FEC0::/10 -j LOG --log-prefix "SITE-LOCAL ADDRESS TRAFFIC: "

### Inspect and Activate Default Rules [ref]group

View the currently-enforced `iptables` rules by running the command:

    $ sudo iptables -nL --line-numbers

The command is analogous for `ip6tables`.
If the firewall does not appear to be active (i.e., no rules appear), activate it and ensure that it starts at boot by issuing the following commands (and analogously for `ip6tables`):

    $ sudo service iptables restart

The default iptables rules are:

    Chain INPUT (policy ACCEPT)
    num  target     prot opt source       destination
    1    ACCEPT     all  --  0.0.0.0/0    0.0.0.0/0    state RELATED,ESTABLISHED
    2    ACCEPT     icmp --  0.0.0.0/0    0.0.0.0/0
    3    ACCEPT     all  --  0.0.0.0/0    0.0.0.0/0
    4    ACCEPT     tcp  --  0.0.0.0/0    0.0.0.0/0    state NEW tcp dpt:22
    5    REJECT     all  --  0.0.0.0/0    0.0.0.0/0    reject-with icmp-host-prohibited

    Chain FORWARD (policy ACCEPT)
    num  target     prot opt source       destination
    1    REJECT     all  --  0.0.0.0/0    0.0.0.0/0    reject-with icmp-host-prohibited

    Chain OUTPUT (policy ACCEPT)
    num  target     prot opt source       destination

The `ip6tables` default rules are essentially the same.

### IPv6 [ref]group

The system includes support for Internet Protocol version 6. A major and often-mentioned improvement over IPv4 is its enormous increase in the number of available addresses. Another important feature is its support for automatic configuration of many network settings.

### Configure IPv6 Settings if Necessary [ref]group

A major feature of IPv6 is the extent to which systems implementing it can automatically configure their networking devices using information from the network. From a security perspective, manually configuring important configuration information is preferable to accepting it from the network in an unauthenticated fashion.

### Limit Network-Transmitted Configuration if Using Static IPv6 Addresses [ref]group

To limit the configuration information requested from other systems and accepted from the network on a system that uses statically-configured IPv6 addresses, add the following lines to `/etc/sysctl.conf`:

    net.ipv6.conf.default.router_solicitations = 0
    net.ipv6.conf.default.accept_ra_rtr_pref = 0
    net.ipv6.conf.default.accept_ra_pinfo = 0
    net.ipv6.conf.default.accept_ra_defrtr = 0
    net.ipv6.conf.default.autoconf = 0
    net.ipv6.conf.default.dad_transmits = 0
    net.ipv6.conf.default.max_addresses = 1

The `router_solicitations` setting determines how many router solicitations are sent when bringing up the interface. If addresses are statically assigned, there is no need to send any solicitations.
The `accept_ra_pinfo` setting controls whether the system will accept prefix info from the router.
The `accept_ra_defrtr` setting controls whether the system will accept Hop Limit settings from a router advertisement. Setting it to 0 prevents a router from changing your default IPv6 Hop Limit for outgoing packets.
The `autoconf` setting controls whether router advertisements can cause the system to assign a global unicast address to an interface.
The `dad_transmits` setting determines how many neighbor solicitations to send out per address (global and link-local) when bringing up an interface to ensure the desired address is unique on the network.
The `max_addresses` setting determines how many global unicast IPv6 addresses can be assigned to each interface. The default is 16, but it should be set to exactly the number of statically configured global addresses required.

### Disable Automatic Configuration [ref]group

Disable the system's acceptance of router advertisements and redirects by adding or correcting the following line in `/etc/sysconfig/network` (note that this does not disable sending router solicitations):

    IPV6_AUTOCONF=no

### Disable Support for IPv6 Unless Needed [ref]group

Despite configuration that suggests support for IPv6 has been disabled, link-local IPv6 address auto-configuration occurs even when only an IPv4 address is assigned. The only way to effectively prevent execution of the IPv6 networking stack is to instruct the system not to activate the IPv6 kernel module.

### Kernel Parameters Which Affect Networking [ref]group

The `sysctl` utility is used to set parameters which affect the operation of the Linux kernel. Kernel parameters which affect networking and have security implications are described here.

### Network Related Kernel Runtime Parameters for Hosts and Routers [ref]group

Certain kernel parameters should be set for systems which are acting as either hosts or routers to improve the system's ability defend against certain types of IPv4 protocol attacks.

### Network Parameters for Hosts Only [ref]group

If the system is not going to be used as a router, then setting certain kernel parameters ensure that the host will not perform routing of network traffic.

### Transport Layer Security Support [ref]group

Support for Transport Layer Security (TLS), and its predecessor, the Secure Sockets Layer (SSL), is included in Red Hat Enterprise Linux in the OpenSSL software (RPM package `openssl`). TLS provides encrypted and authenticated network communications, and many network services include support for it. TLS or SSL can be leveraged to avoid any plaintext transmission of sensitive data.
For information on how to use OpenSSL, see http://www.openssl.org/docs/. Information on FIPS validation of OpenSSL is available at http://www.openssl.org/docs/fips.html and http://csrc.nist.gov/groups/STM/cmvp/documents/140-1/140val-all.htm.

### Disable Unused Interfaces [ref]group

Network interfaces expand the attack surface of the system. Unused interfaces are not monitored or controlled, and should be disabled.
If the system does not require network communications but still needs to use the loopback interface, remove all files of the form `ifcfg-interface` except for `ifcfg-lo` from `/etc/sysconfig/network-scripts`:

    $ sudo rm /etc/sysconfig/network-scripts/ifcfg-interface

If the system is a standalone machine with no need for network access or even communication over the loopback device, then disable this service. The `network` service can be disabled with the following command:

    $ sudo chkconfig network off

### Uncommon Network Protocols [ref]group

The system includes support for several network protocols which are not commonly used. Although security vulnerabilities in kernel networking code are not frequently discovered, the consequences can be dramatic. Ensuring uncommon network protocols are disabled reduces the system's risk to attacks targeted at its implementation of those protocols.

### Wireless Networking [ref]group

Wireless networking, such as 802.11 (WiFi) and Bluetooth, can present a security risk to sensitive or classified systems and networks. Wireless networking hardware is much more likely to be included in laptop or portable systems than in desktops or servers.
Removal of hardware provides the greatest assurance that the wireless capability remains disabled. Acquisition policies often include provisions to prevent the purchase of equipment that will be used in sensitive spaces and includes wireless capabilities. If it is impractical to remove the wireless hardware, and policy permits the device to enter sensitive spaces as long as wireless is disabled, efforts should instead focus on disabling wireless capability via software.

### Disable Wireless Through Software Configuration [ref]group

If it is impossible to remove the wireless hardware from the device in question, disable as much of it as possible through software. The following methods can disable software support for wireless networking, but note that these methods do not prevent malicious software or careless users from re-activating the devices.

### SELinux [ref]group

SELinux is a feature of the Linux kernel which can be used to guard against misconfigured or compromised programs. SELinux enforces the idea that programs should be limited in what files they can access and what actions they can take.
The default SELinux policy, as configured on Red Hat Enterprise Linux 6, has been sufficiently developed and debugged that it should be usable on almost any Red Hat machine with minimal configuration and a small amount of system administrator training. This policy prevents system services - including most of the common network-visible services such as mail servers, FTP servers, and DNS servers - from accessing files which those services have no valid reason to access. This action alone prevents a huge amount of possible damage from network attacks against services, from trojaned software, and so forth.
This guide recommends that SELinux be enabled using the default (targeted) policy on every Red Hat system, unless that system has unusual requirements which make a stronger policy appropriate.

### Account and Access Control [ref]group

In traditional Unix security, if an attacker gains shell access to a certain login account, they can perform any action or access any file to which that account has access. Therefore, making it more difficult for unauthorized people to gain shell access to accounts, particularly to privileged accounts, is a necessary part of securing a system. This section introduces mechanisms for restricting access to accounts under Red Hat Enterprise Linux 6.

### Protect Accounts by Restricting Password-Based Login [ref]group

Conventionally, Unix shell accounts are accessed by providing a username and password to a login program, which tests these values for correctness using the `/etc/passwd` and `/etc/shadow` files. Password-based login is vulnerable to guessing of weak passwords, and to sniffing and man-in-the-middle attacks against passwords entered over a network or at an insecure console. Therefore, mechanisms for accessing accounts by entering usernames and passwords should be restricted to those which are operationally necessary.

### Restrict Root Logins [ref]group

Direct root logins should be allowed only for emergency use. In normal situations, the administrator should access the system via a unique unprivileged account, and then use `su` or `sudo` to execute privileged commands. Discouraging administrators from accessing the root account directly ensures an audit trail in organizations with multiple administrators. Locking down the channels through which root can connect directly also reduces opportunities for password-guessing against the root account. The `login` program uses the file `/etc/securetty` to determine which interfaces should allow root logins. The virtual devices `/dev/console` and `/dev/tty*` represent the system consoles (accessible via the Ctrl-Alt-F1 through Ctrl-Alt-F6 keyboard sequences on a default installation). The default securetty file also contains `/dev/vc/*`. These are likely to be deprecated in most environments, but may be retained for compatibility. Root should also be prohibited from connecting via network protocols. Other sections of this document include guidance describing how to prevent root from logging in via SSH.

### Verify Proper Storage and Existence of Password Hashes [ref]group

By default, password hashes for local accounts are stored in the second field (colon-separated) in `/etc/shadow`. This file should be readable only by processes running with root credentials, preventing users from casually accessing others' password hashes and attempting to crack them. However, it remains possible to misconfigure the system and store password hashes in world-readable files such as `/etc/passwd`, or to even store passwords themselves in plaintext on the system. Using system-provided tools for password change/creation should allow administrators to avoid such misconfiguration.

### Set Password Expiration Parameters [ref]group

The file `/etc/login.defs` controls several password-related settings. Programs such as `passwd`, `su`, and `login` consult `/etc/login.defs` to determine behavior with regard to password aging, expiration warnings, and length. See the man page `login.defs(5)` for more information.
Users should be forced to change their passwords, in order to decrease the utility of compromised passwords. However, the need to change passwords often should be balanced against the risk that users will reuse or write down passwords if forced to change them too often. Forcing password changes every 90-360 days, depending on the environment, is recommended. Set the appropriate value as `PASS_MAX_DAYS` and apply it to existing accounts with the `-M` flag.
The `PASS_MIN_DAYS` (`-m`) setting prevents password changes for 7 days after the first change, to discourage password cycling. If you use this setting, train users to contact an administrator for an emergency password change in case a new password becomes compromised. The `PASS_WARN_AGE` (`-W`) setting gives users 7 days of warnings at login time that their passwords are about to expire.
For example, for each existing human user USER, expiration parameters could be adjusted to a 180 day maximum password age, 7 day minimum password age, and 7 day warning period with the following command:

    $ sudo chage -M 180 -m 7 -W 7 USER

### Set Account Expiration Parameters [ref]group

Accounts can be configured to be automatically disabled after a certain time period, meaning that they will require administrator interaction to become usable again. Expiration of accounts after inactivity can be set for all accounts by default and also on a per-account basis, such as for accounts that are known to be temporary. To configure automatic expiration of an account following the expiration of its password (that is, after the password has expired and not been changed), run the following command, substituting `NUM_DAYS` and `USER` appropriately:

    $ sudo chage -I NUM_DAYS USER

Accounts, such as temporary accounts, can also be configured to expire on an explicitly-set date with the `-E` option. The file `/etc/default/useradd` controls default settings for all newly-created accounts created with the system's normal command line utilities.

### Protect Physical Console Access [ref]group

It is impossible to fully protect a system from an attacker with physical access, so securing the space in which the system is located should be considered a necessary step. However, there are some steps which, if taken, make it more difficult for an attacker to quickly or undetectably modify a system from its console.

### Configure Screen Locking [ref]group

When a user must temporarily leave an account logged-in, screen locking should be employed to prevent passersby from abusing the account. User education and training is particularly important for screen locking to be effective, and policies can be implemented to reinforce this.
Automatic screen locking is only meant as a safeguard for those cases where a user forgot to lock the screen.

### Configure Console Screen Locking [ref]group

A console screen locking mechanism is provided in the `screen` package, which is not installed by default.

### Hardware Tokens for Authentication [ref]group

The use of hardware tokens such as smart cards for system login provides stronger, two-factor authentication than using a username and password. In Red Hat Enterprise Linux servers and workstations, hardware token login is not enabled by default and must be enabled in the system settings.

### Set Boot Loader Password [ref]group

During the boot process, the boot loader is responsible for starting the execution of the kernel and passing options to it. The boot loader allows for the selection of different kernels - possibly on different partitions or media. The default Red Hat Enterprise Linux boot loader for x86 systems is called GRUB. Options it can pass to the kernel include single-user mode, which provides root access without any authentication, and the ability to disable SELinux. To prevent local users from modifying the boot parameters and endangering security, protect the boot loader configuration with a password and ensure its configuration file's permissions are set properly.

### Secure Session Configuration Files for Login Accounts [ref]group

When a user logs into a Unix account, the system configures the user's session by reading a number of files. Many of these files are located in the user's home directory, and may have weak permissions as a result of user error or misconfiguration. If an attacker can modify or even read certain types of account configuration information, they can often gain full access to the affected user's account. Therefore, it is important to test and correct configuration file permissions for interactive accounts, particularly those of privileged users such as root or system administrators.

### Ensure that No Dangerous Directories Exist in Root's Path [ref]group

The active path of the root account can be obtained by starting a new root shell and running:

    $ sudo echo $PATH

This will produce a colon-separated list of directories in the path.
Certain path elements could be considered dangerous, as they could lead to root executing unknown or untrusted programs, which could contain malicious code. Since root may sometimes work inside untrusted directories, the `.` character, which represents the current directory, should never be in the root path, nor should any directory which can be written to by an unprivileged or semi-privileged (system) user.
It is a good practice for administrators to always execute privileged commands by typing the full path to the command.

### Ensure that Users Have Sensible Umask Values [ref]group

The umask setting controls the default permissions for the creation of new files. With a default `umask` setting of 077, files and directories created by users will not be readable by any other user on the system. Users who wish to make specific files group- or world-readable can accomplish this by using the chmod command. Additionally, users can make all their files readable to their group by default by setting a `umask` of 027 in their shell configuration files. If default per-user groups exist (that is, if every user has a default group whose name is the same as that user's username and whose only member is the user), then it may even be safe for users to select a `umask` of 007, making it very easy to intentionally share files with groups of which the user is a member.

### Warning Banners for System Accesses [ref]group

Each system should expose as little information about itself as possible.
System banners, which are typically displayed just before a login prompt, give out information about the service or the host's operating system. This might include the distribution name and the system kernel version, and the particular version of a network service. This information can assist intruders in gaining access to the system as it can reveal whether the system is running vulnerable software. Most network services can be configured to limit what information is displayed.
Many organizations implement security policies that require a system banner provide notice of the system's ownership, provide warning to unauthorized users, and remind authorized users of their consent to monitoring.

### Implement a GUI Warning Banner [ref]group

In the default graphical environment, users logging directly into the system are greeted with a login screen provided by the GNOME Display Manager (GDM). The warning banner should be displayed in this graphical environment for these users. The following sections describe how to configure the GDM login banner.

### Protect Accounts by Configuring PAM [ref]group

PAM, or Pluggable Authentication Modules, is a system which implements modular authentication for Linux programs. PAM provides a flexible and configurable architecture for authentication, and it should be configured to minimize exposure to unnecessary risk. This section contains guidance on how to accomplish that.
PAM is implemented as a set of shared objects which are loaded and invoked whenever an application wishes to authenticate a user. Typically, the application must be running as root in order to take advantage of PAM, because PAM's modules often need to be able to access sensitive stores of account information, such as /etc/shadow. Traditional privileged network listeners (e.g. sshd) or SUID programs (e.g. sudo) already meet this requirement. An SUID root application, userhelper, is provided so that programs which are not SUID or privileged themselves can still take advantage of PAM.
PAM looks in the directory `/etc/pam.d` for application-specific configuration information. For instance, if the program login attempts to authenticate a user, then PAM's libraries follow the instructions in the file `/etc/pam.d/login` to determine what actions should be taken.
One very important file in `/etc/pam.d` is `/etc/pam.d/system-auth`. This file, which is included by many other PAM configuration files, defines 'default' system authentication measures. Modifying this file is a good way to make far-reaching authentication changes, for instance when implementing a centralized authentication service.

### Set Password Hashing Algorithm [ref]group

The system's default algorithm for storing password hashes in `/etc/shadow` is SHA-512. This can be configured in several locations.

### Set Lockouts for Failed Password Attempts [ref]group

The `pam_faillock` PAM module provides the capability to lock out user accounts after a number of failed login attempts. Its documentation is available in `/usr/share/doc/pam-VERSION/txts/README.pam_faillock`.

### Set Password Quality Requirements [ref]group

The default `pam_cracklib` PAM module provides strength checking for passwords. It performs a number of checks, such as making sure passwords are not similar to dictionary words, are of at least a certain length, are not the previous password reversed, and are not simply a change of case from the previous password. It can also require passwords to be in certain character classes.
The man page `pam_cracklib(8)` provides information on the capabilities and configuration of each.

### Set Password Quality Requirements, if using pam_cracklib [ref]group

The `pam_cracklib` PAM module can be configured to meet requirements for a variety of policies.
For example, to configure `pam_cracklib` to require at least one uppercase character, lowercase character, digit, and other (special) character, locate the following line in `/etc/pam.d/system-auth`:

    password requisite pam_cracklib.so try_first_pass retry=3

and then alter it to read:

    password required pam_cracklib.so try_first_pass retry=3 maxrepeat=3 minlen=14 dcredit=-1 ucredit=-1 ocredit=-1 lcredit=-1 difok=4

If no such line exists, add one as the first line of the password section in `/etc/pam.d/system-auth`. The arguments can be modified to ensure compliance with your organization's security policy. Discussion of each parameter follows.

### Protect Random-Number Entropy Pool [ref]group

The I/O operations of the Linux kernel block layer due to their inherently unpredictable execution times have been traditionally considered as a reliable source to contribute to random-number entropy pool of the Linux kernel. This has changed with introduction of solid-state storage devices (SSDs) though.

### File Permissions and Masks [ref]group

Traditional Unix security relies heavily on file and directory permissions to prevent unauthorized users from reading or modifying files to which they should not have access.
Several of the commands in this section search filesystems for files or directories with certain characteristics, and are intended to be run on every local partition on a given system. When the variable PART appears in one of the commands below, it means that the command is intended to be run repeatedly, with the name of each local partition substituted for PART in turn.
The following command prints a list of all xfs partitions on the local system, which is the default filesystem for Red Hat Enterprise Linux 7 installations:

    $ mount -t xfs | awk '{print $3}'

For any systems that use a different local filesystem type, modify this command as appropriate.

### Verify Permissions on Important Files and Directories [ref]group

Permissions for many files on a system must be set restrictively to ensure sensitive information is properly protected. This section discusses important permission restrictions which can be verified to ensure that no harmful discrepancies have arisen.

### Verify Permissions on Files with Local Account Information and Credentials [ref]group

The default restrictive permissions for files which act as important security databases such as `passwd`, `shadow`, `group`, and `gshadow` files must be maintained. Many utilities need read access to the `passwd` file in order to function properly, but read access to the `shadow` file allows malicious attacks against system passwords, and should never be enabled.

### Verify File Permissions Within Some Important Directories [ref]group

Some directories contain files whose confidentiality or integrity is notably important and may also be susceptible to misconfiguration over time, particularly if unpackaged software is installed. As such, an argument exists to verify that files' permissions within these directories remain configured correctly and restrictively.

### Restrict Dynamic Mounting and Unmounting of Filesystems [ref]group

Linux includes a number of facilities for the automated addition and removal of filesystems on a running system. These facilities may be necessary in many environments, but this capability also carries some risk -- whether direct risk from allowing users to introduce arbitrary filesystems, or risk that software flaws in the automated mount facility itself could allow an attacker to compromise the system.
This command can be used to list the types of filesystems that are available to the currently executing kernel:

    $ find /lib/modules/`uname -r`/kernel/fs -type f -name '*.ko'

If these filesystems are not required then they can be explicitly disabled in a configuratio file in `/etc/modprobe.d`.

### Restrict Partition Mount Options [ref]group

System partitions can be mounted with certain options that limit what files on those partitions can do. These options are set in the `/etc/fstab` configuration file, and can be used to make certain types of malicious behavior more difficult.

### Restrict Programs from Dangerous Execution Patterns [ref]group

The recommendations in this section are designed to ensure that the system's features to protect against potentially dangerous program execution are activated. These protections are applied at the system initialization or kernel level, and defend against certain types of badly-configured or compromised programs.

### Daemon Umask [ref]group

The umask is a per-process setting which limits the default permissions for creation of new files and directories. The system includes initialization scripts which set the default umask for system daemons.

### Enable Execute Disable (XD) or No Execute (NX) Support on x86 Systems [ref]group

Recent processors in the x86 family support the ability to prevent code execution on a per memory page basis. Generically and on AMD processors, this ability is called No Execute (NX), while on Intel processors it is called Execute Disable (XD). This ability can help prevent exploitation of buffer overflow vulnerabilities and should be activated whenever possible. Extra steps must be taken to ensure that this protection is enabled, particularly on 32-bit x86 systems. Other processors, such as Itanium and POWER, have included such support since inception and the standard kernel for those platforms supports the feature.

### Disable Core Dumps [ref]group

A core dump file is the memory image of an executable program when it was terminated by the operating system due to errant behavior. In most cases, only software developers legitimately need to access these files. The core dump files may also contain sensitive information, or unnecessarily occupy large amounts of disk space.
Once a hard limit is set in `/etc/security/limits.conf`, a user cannot increase that limit within his or her own session. If access to core dumps is required, consider restricting them to only certain users or groups. See the `limits.conf` man page for more information.
The core dumps of setuid programs are further protected. The `sysctl` variable `fs.suid_dumpable` controls whether the kernel allows core dumps from these programs at all. The default value of 0 is recommended.

### Enable ExecShield [ref]group

ExecShield describes kernel features that provide protection against exploitation of memory corruption errors such as buffer overflows. These features include random placement of the stack and other memory regions, prevention of execution in memory that should only hold data, and special handling of text buffers. These protections are enabled by default and controlled through `sysctl` variables `kernel.exec-shield` and `kernel.randomize_va_space`.

### System Accounting with <tt>auditd</tt> [ref]group

The audit service provides substantial capabilities for recording system activities. By default, the service audits about SELinux AVC denials and certain types of security-relevant events such as system logins, account modifications, and authentication events performed by programs such as sudo. Under its default configuration, `auditd` has modest disk space requirements, and should not noticeably impact system performance.
Government networks often have substantial auditing requirements and `auditd` can be configured to meet these requirements. Examining some example audit records demonstrates how the Linux audit system satisfies common requirements. The following example from Fedora Documentation available at `http://docs.fedoraproject.org/en-US/Fedora/13/html/Security-Enhanced_Linux/sect-Security-Enhanced_Linux-Fixing_Problems-Raw_Audit_Messages.html` shows the substantial amount of information captured in a two typical "raw" audit messages, followed by a breakdown of the most important fields. In this example the message is SELinux-related and reports an AVC denial (and the associated system call) that occurred when the Apache HTTP Server attempted to access the `/var/www/html/file1` file (labeled with the `samba_share_t` type):

    type=AVC msg=audit(1226874073.147:96): avc:  denied  { getattr } for pid=2465 comm="httpd"
    path="/var/www/html/file1" dev=dm-0 ino=284133 scontext=unconfined_u:system_r:httpd_t:s0
    tcontext=unconfined_u:object_r:samba_share_t:s0 tclass=file

    type=SYSCALL msg=audit(1226874073.147:96): arch=40000003 syscall=196 success=no exit=-13
    a0=b98df198 a1=bfec85dc a2=54dff4 a3=2008171 items=0 ppid=2463 pid=2465 auid=502 uid=48
    gid=48 euid=48 suid=48 fsuid=48 egid=48 sgid=48 fsgid=48 tty=(none) ses=6 comm="httpd"
    exe="/usr/sbin/httpd" subj=unconfined_u:system_r:httpd_t:s0 key=(null)

- `msg=audit(1226874073.147:96)`
  - The number in parentheses is the unformatted time stamp (Epoch time) for the event, which can be converted to standard time by using the `date` command.
- `{ getattr }`
  - The item in braces indicates the permission that was denied. `getattr` indicates the source process was trying to read the target file's status information. This occurs before reading files. This action is denied due to the file being accessed having the wrong label. Commonly seen permissions include `getattr`, `read`, and `write`.
- `comm="httpd"`
  - The executable that launched the process. The full path of the executable is found in the `exe=` section of the system call (`SYSCALL`) message, which in this case, is `exe="/usr/sbin/httpd"`.
- `path="/var/www/html/file1"`
  - The path to the object (target) the process attempted to access.
- `scontext="unconfined_u:system_r:httpd_t:s0"`
  - The SELinux context of the process that attempted the denied action. In this case, it is the SELinux context of the Apache HTTP Server, which is running in the `httpd_t` domain.
- `tcontext="unconfined_u:object_r:samba_share_t:s0"`
  - The SELinux context of the object (target) the process attempted to access. In this case, it is the SELinux context of `file1`. Note: the `samba_share_t` type is not accessible to processes running in the `httpd_t` domain.
- From the system call (`SYSCALL`) message, two items are of interest:
  - `success=no`: indicates whether the denial (AVC) was enforced or not. `success=no` indicates the system call was not successful (SELinux denied access). `success=yes` indicates the system call was successful - this can be seen for permissive domains or unconfined domains, such as `initrc_t` and `kernel_t`.
  - `exe="/usr/sbin/httpd"`: the full path to the executable that launched the process, which in this case, is `exe="/usr/sbin/httpd"`.

### Configure <tt>auditd</tt> Data Retention [ref]group

The audit system writes data to `/var/log/audit/audit.log`. By default, `auditd` rotates 5 logs by size (6MB), retaining a maximum of 30MB of data in total, and refuses to write entries when the disk is too full. This minimizes the risk of audit data filling its partition and impacting other services. This also minimizes the risk of the audit daemon temporarily disabling the system if it cannot write audit log (which it can be configured to do). For a busy system or a system which is thoroughly auditing system activity, the default settings for data retention may be insufficient. The log file size needed will depend heavily on what types of events are being audited. First configure auditing to log all the events of interest. Then monitor the log size manually for awhile to determine what file size will allow you to keep the required data for the correct time period.
Using a dedicated partition for `/var/log/audit` prevents the `auditd` logs from disrupting system functionality if they fill, and, more importantly, prevents other activity in `/var` from filling the partition and stopping the audit trail. (The audit logs are size-limited and therefore unlikely to grow without bound unless configured to do so.) Some machines may have requirements that no actions occur which cannot be audited. If this is the case, then `auditd` can be configured to halt the machine if it runs out of space. Note: Since older logs are rotated, configuring `auditd` this way does not prevent older logs from being rotated away before they can be viewed. If your system is configured to halt when logging cannot be performed, make sure this can never happen under normal circumstances! Ensure that `/var/log/audit` is on its own partition, and that this partition is larger than the maximum amount of data `auditd` will retain normally.

### Configure <tt>auditd</tt> Rules for Comprehensive Auditing [ref]group

The `auditd` program can perform comprehensive monitoring of system activity. This section describes recommended configuration settings for comprehensive auditing, but a full description of the auditing system's capabilities is beyond the scope of this guide. The mailing list linux-audit@redhat.com exists to facilitate community discussion of the auditing system.
The audit subsystem supports extensive collection of events, including:

- Tracing of arbitrary system calls (identified by name or number) on entry or exit.
- Filtering by PID, UID, call success, system call argument (with some limitations), etc.
- Monitoring of specific files for modifications to the file's contents or metadata.

Auditing rules at startup are controlled by the file `/etc/audit/audit.rules`. Add rules to it to meet the auditing requirements for your organization. Each line in `/etc/audit/audit.rules` represents a series of arguments that can be passed to `auditctl` and can be individually tested during runtime. See documentation in `/usr/share/doc/audit-VERSION` and in the related man pages for more details.
If copying any example audit rulesets from `/usr/share/doc/audit-VERSION`, be sure to comment out the lines containing `arch=` which are not appropriate for your system's architecture. Then review and understand the following rules, ensuring rules are activated as needed for the appropriate architecture.
After reviewing all the rules, reading the following sections, and editing as needed, the new rules can be activated as follows:

    $ sudo service auditd restart

### Record Events that Modify the System's Discretionary Access Controls [ref]group

At a minimum, the audit system should collect file permission changes for all users and root. Note that the "-F arch=b32" lines should be present even on a 64 bit system. These commands identify system calls for auditing. Even if the system is 64 bit it can still execute 32 bit system calls. Additionally, these rules can be configured in a number of ways while still achieving the desired effect. An example of this is that the "-S" calls could be split up and placed on separate lines, however, this is less efficient. Add the following to `/etc/audit/audit.rules`:

    -a always,exit -F arch=b32 -S chmod -S fchmod -S fchmodat -F auid>=500 -F auid!=4294967295 -k perm_mod
        -a always,exit -F arch=b32 -S chown -S fchown -S fchownat -S lchown -F auid>=500 -F auid!=4294967295 -k perm_mod
        -a always,exit -F arch=b32 -S setxattr -S lsetxattr -S fsetxattr -S removexattr -S lremovexattr -S fremovexattr -F auid>=500 -F auid!=4294967295 -k perm_mod

If your system is 64 bit then these lines should be duplicated and the arch=b32 replaced with arch=b64 as follows:

    -a always,exit -F arch=b64 -S chmod -S fchmod -S fchmodat -F auid>=500 -F auid!=4294967295 -k perm_mod
        -a always,exit -F arch=b64 -S chown -S fchown -S fchownat -S lchown -F auid>=500 -F auid!=4294967295 -k perm_mod
        -a always,exit -F arch=b64 -S setxattr -S lsetxattr -S fsetxattr -S removexattr -S lremovexattr -S fremovexattr -F auid>=500 -F auid!=4294967295 -k perm_mod

### Records Events that Modify Date and Time Information [ref]group

Arbitrary changes to the system time can be used to obfuscate nefarious activities in log files, as well as to confuse network services that are highly dependent upon an accurate system time. All changes to the system time should be audited.

### Installing and Maintaining Software [ref]group

The following sections contain information on security-relevant choices during the initial operating system installation process and the setup of software updates.

### Sudo [ref]group

`Sudo`, which stands for "su 'do'", provides the ability to delegate authority to certain users, groups of users, or system administrators. When configured for system users and/or groups, `Sudo` can allow a user or group to execute privileged commands that normally only `root` is allowed to execute.
For more information on `Sudo` and addition `Sudo` configuration options, see https://www.sudo.ws

### Software Integrity Checking [ref]group

Both the AIDE (Advanced Intrusion Detection Environment) software and the RPM package management system provide mechanisms for verifying the integrity of installed software. AIDE uses snapshots of file metadata (such as hashes) and compares these to current system files in order to detect changes. The RPM package management system can conduct integrity checks by comparing information in its metadata database with files installed on the system.
Integrity checking cannot prevent intrusions, but can detect that they have occurred. Requirements for software integrity checking may be highly dependent on the environment in which the system will be used. Snapshot-based approaches such as AIDE may induce considerable overhead in the presence of frequent software updates.

### Federal Information Processing Standard (FIPS) [ref]group

The Federal Information Processing Standard (FIPS) is a computer security standard which is developed by the U.S. Government and industry working groups to validate the quality of cryptographic modules. The FIPS standard provides four security levels to ensure adequate coverage of different industries, implementation of cryptographic modules, and organizational sizes and requirements.
FIPS 140-2 is the current standard for validating that mechanisms used to access cryptographic modules utilize authentication that meets industry and government requirements. For government systems, this allows Security Levels 1, 2, 3, or 4 for use on Red Hat Enterprise Linux.
See http://csrc.nist.gov/publications/PubsFIPS.html for more information.

### Operating System Vendor Support and Certification [ref]group

The assurance of a vendor to provide operating system support and maintenance for their product is an important criterion to ensure product stability and security over the life of the product. A certified product that follows the necessary standards and government certification requirements guarantees that known software vulnerabilities will be remediated, and proper guidance for protecting and securing the operating system will be given.

### Verify Integrity with RPM [ref]group

The RPM package management system includes the ability to verify the integrity of installed packages by comparing the installed files with information about the files taken from the package metadata stored in the RPM database. Although an attacker could corrupt the RPM database (analogous to attacking the AIDE database as described above), this check can still reveal modification of important files. To list which files on the system differ from what is expected by the RPM database:

    $ rpm -qVa

See the man page for `rpm` to see a complete explanation of each column.

### Additional Security Software [ref]group

Additional security software that is not provided or supported by Red Hat can be installed to provide complementary or duplicative security capabilities to those provided by the base platform. Add-on software may not be appropriate for some specialized systems.

### Verify Integrity with AIDE [ref]group

AIDE conducts integrity checks by comparing information about files with previously-gathered information. Ideally, the AIDE database is created immediately after initial system configuration, and then again after any software update. AIDE is highly configurable, with further configuration information located in `/usr/share/doc/aide-VERSION`.

### GNOME Desktop Environment [ref]group

GNOME is a graphical desktop environment bundled with many Linux distributions that allow users to easily interact with the operating system graphically rather than textually. The GNOME Graphical Display Manager (GDM) provides login, logout, and user switching contexts as well as display server management.
GNOME is developed by the GNOME Project and is considered the default Red Hat Graphical environment.
For more information on GNOME and the GNOME Project, see https://www.gnome.org

### Configure GNOME Screen Locking [ref]group

In the default GNOME desktop, the screen can be locked by choosing Lock Screen from the System menu.
The `gconftool-2` program can be used to enforce mandatory screen locking settings for the default GNOME environment. The following sections detail commands to enforce idle activation of the screensaver, screen locking, a blank-screen screensaver, and an idle activation time.
Because users should be trained to lock the screen when they step away from the computer, the automatic locking feature is only meant as a backup. The Lock Screen icon from the System menu can also be dragged to the taskbar in order to facilitate even more convenient screen-locking.
The root account cannot be screen-locked, but this should have no practical effect as the root account should never be used to log into an X Windows environment, and should only be used to for direct login via console in emergency circumstances.
For more information about configuring GNOME screensaver, see http://live.gnome.org/GnomeScreensaver. For more information about enforcing preferences in the GNOME environment using the GConf configuration system, see http://projects.gnome.org/gconf and the man page `gconftool-2(1)`.

### GNOME Media Settings [ref]group

GNOME media settings that apply to the graphical interface.

### GNOME System Settings [ref]group

GNOME provides configuration and functionality to a graphical desktop environment that changes grahical configurations or allow a user to perform actions that users normally would not be able to do in non-graphical mode such as remote access configuration, power policies, Geo-location, etc. Configuring such settings in GNOME will prevent accidential graphical configuration changes by users from taking place.

### Configure GNOME Login Screen [ref]group

In the default GNOME desktop, the login is displayed after system boot and can display user accounts, allow users to reboot the system, and allow users to login automatically and/or with a guest account. The login screen should be configured to prevent such behavior.
For more information about enforcing preferences in the GNOME environment using the GConf configuration system, see http://projects.gnome.org/gconf and the man page `gconftool-2(1)`.

### GNOME Network Settings [ref]group

GNOME network settings that apply to the graphical interface.

### GNOME Remote Access Settings [ref]group

GNOME remote access settings that apply to the graphical interface.

### Updating Software [ref]group

The `yum` command line tool is used to install and update software packages. The system also provides a graphical software update tool in the System menu, in the Administration submenu, called Software Update.
Red Hat Enterprise Linux systems contain an installed software catalog called the RPM database, which records metadata of installed packages. Consistently using `yum` or the graphical Software Update for all software installation allows for insight into the current inventory of installed software on the system.

### Disk Partitioning [ref]group

To ensure separation and protection of data, there are top-level system directories which should be placed on their own physical partition or logical volume. The installer's default partitioning scheme creates separate logical volumes for `/`, `/boot`, and `swap`.

- If starting with any of the default layouts, check the box to "Review and modify partitioning." This allows for the easy creation of additional logical volumes inside the volume group already created, though it may require making `/`'s logical volume smaller to create space. In general, using logical volumes is preferable to using partitions because they can be more easily adjusted later.
- If creating a custom layout, create the partitions mentioned in the previous paragraph (which the installer will require anyway), as well as separate ones described in the following sections.

If a system has already been installed, and the default partitioning scheme was used, it is possible but nontrivial to modify it to create separate logical volumes for the directories listed above. The Logical Volume Manager (LVM) makes this possible. See the LVM HOWTO at http://tldp.org/HOWTO/LVM-HOWTO/ for more detailed information on LVM.

Red Hat and Red Hat Enterprise Linux are either registered trademarks or trademarks of Red Hat, Inc. in the United States and other countries. All other names are registered trademarks or trademarks of their respective companies.