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

> with profile Red Hat Corporate Profile for Certified Cloud Providers (RH CCP)
> This is a *draft* SCAP profile for Red Hat Certified Cloud Providers

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 7. 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 `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 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 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 7, 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 Title | Red Hat Corporate Profile for Certified Cloud Providers (RH CCP)
Profile ID | xccdf_org.ssgproject.content_profile_rht-ccp

## Revision History

Current version: 0.1.31

- draft (as of 2017-08-11)

## Platforms

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

## Table of Contents

1. System Settings

1. Installing and Maintaining Software
2. File Permissions and Masks
3. SELinux
4. Account and Access Control
5. Network Configuration and Firewalls
6. System Accounting with auditd

2. Services

1. Obsolete Services
2. Base Services
3. SSH Server

## Checklist

contains 69 rules

### System Settings [ref]group

Contains rules that check correct system settings.

contains 55 rules

### 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.

contains 9 rules

### 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.

contains 4 rules

#### Ensure /tmp Located On Separate Partition [ref]rule

The `/tmp` directory is a world-writable directory used for temporary file storage. Ensure it has its own partition or logical volume at installation time, or migrate it using LVM.

Rationale:

The `/tmp` partition is used as temporary storage by many programs. Placing `/tmp` in its own partition enables the setting of more restrictive mount options, which can help protect programs which use it.

Severity: low

Identifiers: CCE-27173-4

References: SC-32(1), 366, SRG-OS-000480-GPOS-00227, 1.1.1, RHEL-07-021270

#### Ensure /var Located On Separate Partition [ref]rule

The `/var` directory is used by daemons and other system services to store frequently-changing data. Ensure that `/var` has its own partition or logical volume at installation time, or migrate it using LVM.

Rationale:

Ensuring that `/var` is mounted on its own partition enables the setting of more restrictive mount options. This helps protect system services such as daemons or other programs which use it. It is not uncommon for the `/var` directory to contain world-writable directories installed by other software packages.

Severity: low

Identifiers: CCE-26404-4

References: SC-32(1), 1.1.5, 366, SRG-OS-000480-GPOS-00227, RHEL-07-021250

#### Ensure /var/log Located On Separate Partition [ref]rule

System logs are stored in the `/var/log` directory. Ensure that it has its own partition or logical volume at installation time, or migrate it using LVM.

Rationale:

Placing `/var/log` in its own partition enables better separation between log files and other files in `/var/`.

Severity: low

Identifiers: CCE-26967-0

References: AU-9, SC-32, http://iase.disa.mil/stigs/cci/Pages/index.aspx, 1.1.7

#### Ensure /var/log/audit Located On Separate Partition [ref]rule

Audit logs are stored in the `/var/log/audit` directory. Ensure that it has its own partition or logical volume at installation time, or migrate it later using LVM. Make absolutely certain that it is large enough to store all audit logs that will be created by the auditing daemon.

Rationale:

Placing `/var/log/audit` in its own partition enables better separation between audit files and other files, and helps ensure that auditing cannot be halted due to the partition running out of space.

Severity: low

Identifiers: CCE-26971-2

References: AU-4, AU-9, SC-32(1), 366, 1.1.8, SRG-OS-000480-GPOS-00227, RHEL-07-021260

### 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.

contains 4 rules

#### Ensure Red Hat GPG Key Installed [ref]rule

To ensure the system can cryptographically verify base software packages come from Red Hat (and to connect to the Red Hat Network to receive them), the Red Hat GPG key must properly be installed. To install the Red Hat GPG key, run:

    $ sudo rhn_register

If the system is not connected to the Internet or an RHN Satellite, then install the Red Hat GPG key from trusted media such as the Red Hat installation CD-ROM or DVD. Assuming the disc is mounted in `/media/cdrom`, use the following command as the root user to import it into the keyring:

    $ sudo rpm --import /media/cdrom/RPM-GPG-KEY

Rationale:

Changes to software components can have significant effects on the overall security of the operating system. This requirement ensures the software has not been tampered with and that it has been provided by a trusted vendor. The Red Hat GPG key is necessary to cryptographically verify packages are from Red Hat.

Severity: high

Identifiers: CCE-26957-1

References: CM-5(3), SI-7, MA-1(b), 1749, 366, Req-6.2, 1.2.2

Remediation Shell script: (show)

Complexity: | low
Disruption: | low
Reboot: | false
Strategy: | disable

    # The two fingerprints below are retrieved from https://access.redhat.com/security/team/key
    readonly REDHAT_RELEASE_2_FINGERPRINT="567E 347A D004 4ADE 55BA 8A5F 199E 2F91 FD43 1D51"
    readonly REDHAT_AUXILIARY_FINGERPRINT="43A6 E49C 4A38 F4BE 9ABF 2A53 4568 9C88 2FA6 58E0"
    # Location of the key we would like to import (once it's integrity verified)
    readonly REDHAT_RELEASE_KEY="/etc/pki/rpm-gpg/RPM-GPG-KEY-redhat-release"

    RPM_GPG_DIR_PERMS=$(stat -c %a "$(dirname "$REDHAT_RELEASE_KEY")")

    # Verify /etc/pki/rpm-gpg directory permissions are safe
    if [ "${RPM_GPG_DIR_PERMS}" -le "755" ]
    then
      # If they are safe, try to obtain fingerprints from the key file
      # (to ensure there won't be e.g. CRC error)
      IFS=$'\n' GPG_OUT=($(gpg --with-fingerprint "${REDHAT_RELEASE_KEY}"))
      GPG_RESULT=$?
      # No CRC error, safe to proceed
      if [ "${GPG_RESULT}" -eq "0" ]
      then
        for ITEM in "${GPG_OUT[@]}"
        do
          # Filter just hexadecimal fingerprints from gpg's output from
          # processing of a key file
          RESULT=$(echo ${ITEM} | sed -n "s/[[:space:]]*Key fingerprint = \(.*\)/\1/p" | tr -s '[:space:]')
          # If fingerprint matches Red Hat's release 2 or auxiliary key import the key
          if [[ ${RESULT} ]] && ([[ ${RESULT} = "${REDHAT_RELEASE_2_FINGERPRINT}" ]] || \
                                 [[ ${RESULT} = "${REDHAT_AUXILIARY_FINGERPRINT}" ]])
          then
            rpm --import "${REDHAT_RELEASE_KEY}"
          fi
        done
      fi
    fi

#### Ensure gpgcheck Enabled In Main Yum Configuration [ref]rule

The `gpgcheck` option controls whether RPM packages' signatures are always checked prior to installation. To configure yum to check package signatures before installing them, ensure the following line appears in `/etc/yum.conf` in the `[main]` section:

    gpgcheck=1

Rationale:

Changes to any software components can have significant effects on the overall security of the operating system. This requirement ensures the software has not been tampered with and that it has been provided by a trusted vendor.
Accordingly, patches, service packs, device drivers, or operating system components must be signed with a certificate recognized and approved by the organization.
Verifying the authenticity of the software prior to installation validates the integrity of the patch or upgrade received from a vendor. This ensures the software has not been tampered with and that it has been provided by a trusted vendor. Self-signed certificates are disallowed by this requirement. Certificates used to verify the software must be from an approved Certificate Authority (CA).

Severity: high

Identifiers: CCE-26989-4

References: CM-5(3), SI-7, MA-1(b), 1749, SRG-OS-000366-GPOS-00153, RHEL-07-020150, Req-6.2, 1.2.3

Remediation Shell script: (show)

Complexity: | low
Disruption: | low
Reboot: | false
Strategy: | disable

    sed -i 's/gpgcheck=.*/gpgcheck=1/g' /etc/yum.conf

#### Ensure gpgcheck Enabled For All Yum Package Repositories [ref]rule

To ensure signature checking is not disabled for any repos, remove any lines from files in `/etc/yum.repos.d` of the form:

    gpgcheck=0

Rationale:

Verifying the authenticity of the software prior to installation validates the integrity of the patch or upgrade received from a vendor. This ensures the software has not been tampered with and that it has been provided by a trusted vendor. Self-signed certificates are disallowed by this requirement. Certificates used to verify the software must be from an approved Certificate Authority (CA).

Severity: high

Identifiers: CCE-26876-3

References: CM-5(3), SI-7, MA-1(b), 1749, 366, Req-6.2

Remediation Shell script: (show)

Complexity: | low
Disruption: | low
Reboot: | false
Strategy: | disable

    sed -i 's/gpgcheck=.*/gpgcheck=1/g' /etc/yum.repos.d/*

#### Ensure Software Patches Installed [ref]rule

If the system is joined to the Red Hat Network, a Red Hat Satellite Server, or a yum server, run the following command to install updates:

    $ sudo yum update

If the system is not configured to use one of these sources, updates (in the form of RPM packages) can be manually downloaded from the Red Hat Network and installed using `rpm`.
NOTE: U.S. Defense systems are required to be patched within 30 days or sooner as local policy dictates. Rationale:

Installing software updates is a fundamental mitigation against the exploitation of publicly-known vulnerabilities. If the most recent security patches and updates are not installed, unauthorized users may take advantage of weaknesses in the unpatched software. The lack of prompt attention to patching could result in a system compromise.

Severity: high

Identifiers: CCE-26895-3

References: SI-2, SI-2(c), MA-1(b), 366, Req-6.2, 1.7, SRG-OS-000480-GPOS-00227, RHEL-07-020250

Remediation Shell script: (show)

Complexity: | low
Disruption: | low
Reboot: | false
Strategy: | disable

    yum -y update

### System and Software Integrity [ref]group

System and software integrity can be gained by installing antivirus, increasing system encryption strength with FIPS, verifying installed software, enabling SELinux, installing an Intrusion Prevention System, etc. However, installing or enabling integrity checking tools cannot prevent intrusions, but they can detect that an intrusion may have occurred. Requirements for 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.

contains 1 rule

### 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.

contains 1 rule

### 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`.

contains 1 rule

#### Install AIDE [ref]rule

Install the AIDE package with the command:

    $ sudo yum install aide

Rationale:

The AIDE package must be installed if it is to be available for integrity checking.

Severity: medium

Identifiers: CCE-27096-7

References: CM-3(d), CM-3(e), CM-6(d), CM-6(3), SC-28, SI-7, http://iase.disa.mil/stigs/cci/Pages/index.aspx, Req-11.5, 1.3.1

Remediation Shell script: (show)

Complexity: | low
Disruption: | low
Reboot: | false
Strategy: | enable

    function package_command {

    # Load function arguments into local variables
    local package_operation=$1
    local package=$2

    # Check sanity of the input
    if [ $# -ne "2" ]
    then
      echo "Usage: package_command 'install/uninstall' 'rpm_package_name"
      echo "Aborting."
      exit 1
    fi

    # If dnf is installed, use dnf; otherwise, use yum
    if [ -f "/usr/bin/dnf" ] ; then
      install_util="/usr/bin/dnf"
    else
      install_util="/usr/bin/yum"
    fi

    if [ "$package_operation" != 'remove' ] ; then
      # If the rpm is not installed, install the rpm
      if ! /bin/rpm -q --quiet $package; then
        $install_util -y $package_operation $package
      fi
    else
      # If the rpm is installed, uninstall the rpm
      if /bin/rpm -q --quiet $package; then
        $install_util -y $package_operation $package
      fi
    fi

    }

    package_command install aide

Remediation Ansible snippet: (show)

Complexity: | low
Disruption: | low
Reboot: | false
Strategy: | enable

    - name: Ensure aide is installed
      package:
        name="{{item}}"
        state=present
      with_items:
        - aide

Remediation Puppet snippet: (show)

Complexity: | low
Disruption: | low
Reboot: | false
Strategy: | enable

    include install_aide

    class install_aide {
      package { 'aide':
        ensure => 'installed',
      }
    }

Remediation Anaconda snippet: (show)

Complexity: | low
Disruption: | low
Reboot: | false
Strategy: | enable

    package --add=aide

### 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.

contains 16 rules

### 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.

contains 16 rules

### 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.

contains 12 rules

#### Verify User Who Owns shadow File [ref]rule

To properly set the owner of `/etc/shadow`, run the command:

    $ sudo chown root /etc/shadow

Rationale:

The `/etc/shadow` file contains the list of local system accounts and stores password hashes. Protection of this file is critical for system security. Failure to give ownership of this file to root provides the designated owner with access to sensitive information which could weaken the system security posture.

Severity: medium

Identifiers: CCE-26795-5

References: AC-6, http://iase.disa.mil/stigs/cci/Pages/index.aspx, Req-8.7.c

Remediation Shell script: (show)

Complexity: | low
Disruption: | low
Reboot: | false
Strategy: | disable

    chown root /etc/shadow

#### Verify Group Who Owns shadow File [ref]rule

To properly set the group owner of `/etc/shadow`, run the command:

    $ sudo chgrp root /etc/shadow

Rationale:

The `/etc/shadow` file stores password hashes. Protection of this file is critical for system security.

Severity: medium

Identifiers: CCE-27125-4

References: AC-6, http://iase.disa.mil/stigs/cci/Pages/index.aspx, Req-8.7.c

Remediation Shell script: (show)

Complexity: | low
Disruption: | low
Reboot: | false
Strategy: | disable

    chgrp root /etc/shadow

#### Verify Permissions on shadow File [ref]rule

To properly set the permissions of `/etc/shadow`, run the command:

    $ sudo chmod 0000 /etc/shadow

Rationale:

The `/etc/shadow` file contains the list of local system accounts and stores password hashes. Protection of this file is critical for system security. Failure to give ownership of this file to root provides the designated owner with access to sensitive information which could weaken the system security posture.

Severity: medium

Identifiers: CCE-27100-7

References: AC-6, http://iase.disa.mil/stigs/cci/Pages/index.aspx, Req-8.7.c

Remediation Shell script: (show)

Complexity: | low
Disruption: | low
Reboot: | false
Strategy: | configure

    chmod 0000 /etc/shadow

Remediation Ansible snippet: (show)

Complexity: | low
Disruption: | low
Reboot: | false
Strategy: | configure

    - name: Ensure permission 0000 on /etc/shadow
      file:
        path="{{item}}"
        mode=0000
      with_items:
        - /etc/shadow

#### Verify User Who Owns group File [ref]rule

To properly set the owner of `/etc/group`, run the command:

    $ sudo chown root /etc/group

Rationale:

The `/etc/group` file contains information regarding groups that are configured on the system. Protection of this file is important for system security.

Severity: medium

Identifiers: CCE-26933-2

References: AC-6, Req-8.7.c

Remediation Shell script: (show)

Complexity: | low
Disruption: | low
Reboot: | false
Strategy: | disable

    chown root /etc/group

#### Verify Group Who Owns group File [ref]rule

To properly set the group owner of `/etc/group`, run the command:

    $ sudo chgrp root /etc/group

Rationale:

The `/etc/group` file contains information regarding groups that are configured on the system. Protection of this file is important for system security.

Severity: medium

Identifiers: CCE-27037-1

References: AC-6, http://iase.disa.mil/stigs/cci/Pages/index.aspx, Req-8.7.c

Remediation Shell script: (show)

Complexity: | low
Disruption: | low
Reboot: | false
Strategy: | disable

    chgrp root /etc/group

#### Verify Permissions on group File [ref]rule

To properly set the permissions of `/etc/group`, run the command:

    $ sudo chmod 644 /etc/group

Rationale:

The `/etc/group` file contains information regarding groups that are configured on the system. Protection of this file is important for system security.

Severity: medium

Identifiers: CCE-26949-8

References: AC-6, http://iase.disa.mil/stigs/cci/Pages/index.aspx, Req-8.7.c

Remediation Shell script: (show)

Complexity: | low
Disruption: | low
Reboot: | false
Strategy: | disable

    chmod 644 /etc/group

#### Verify User Who Owns gshadow File [ref]rule

To properly set the owner of `/etc/gshadow`, run the command:

    $ sudo chown root /etc/gshadow

Rationale:

The `/etc/gshadow` file contains group password hashes. Protection of this file is critical for system security.

Severity: medium

Identifiers: CCE-27161-9

References: AC-6, http://iase.disa.mil/stigs/cci/Pages/index.aspx

Remediation Shell script: (show)

Complexity: | low
Disruption: | low
Reboot: | false
Strategy: | disable

    chown root /etc/gshadow

#### Verify Group Who Owns gshadow File [ref]rule

To properly set the group owner of `/etc/gshadow`, run the command:

    $ sudo chgrp root /etc/gshadow

Rationale:

The `/etc/gshadow` file contains group password hashes. Protection of this file is critical for system security.

Severity: medium

Identifiers: CCE-26840-9

References: AC-6, http://iase.disa.mil/stigs/cci/Pages/index.aspx

Remediation Shell script: (show)

Complexity: | low
Disruption: | low
Reboot: | false
Strategy: | disable

    chgrp root /etc/gshadow

#### Verify Permissions on gshadow File [ref]rule

To properly set the permissions of `/etc/gshadow`, run the command:

    $ sudo chmod 0000 /etc/gshadow

Rationale:

The `/etc/gshadow` file contains group password hashes. Protection of this file is critical for system security.

Severity: medium

Identifiers: CCE-27162-7

References: AC-6, http://iase.disa.mil/stigs/cci/Pages/index.aspx

Remediation Shell script: (show)

Complexity: | low
Disruption: | low
Reboot: | false
Strategy: | disable

    chmod 0000 /etc/gshadow

#### Verify User Who Owns passwd File [ref]rule

To properly set the owner of `/etc/passwd`, run the command:

    $ sudo chown root /etc/passwd

Rationale:

The `/etc/passwd` file contains information about the users that are configured on the system. Protection of this file is critical for system security.

Severity: medium

Identifiers: CCE-27138-7

References: AC-6, http://iase.disa.mil/stigs/cci/Pages/index.aspx, Req-8.7.c

Remediation Shell script: (show)

Complexity: | low
Disruption: | low
Reboot: | false
Strategy: | disable

    chown root /etc/passwd

#### Verify Group Who Owns passwd File [ref]rule

To properly set the group owner of `/etc/passwd`, run the command:

    $ sudo chgrp root /etc/passwd

Rationale:

The `/etc/passwd` file contains information about the users that are configured on the system. Protection of this file is critical for system security.

Severity: medium

Identifiers: CCE-26639-5

References: AC-6, http://iase.disa.mil/stigs/cci/Pages/index.aspx, Req-8.7.c

Remediation Shell script: (show)

Complexity: | low
Disruption: | low
Reboot: | false
Strategy: | disable

    chgrp root /etc/passwd

#### Verify Permissions on passwd File [ref]rule

To properly set the permissions of `/etc/passwd`, run the command:

    $ sudo chmod 0644 /etc/passwd

Rationale:

If the `/etc/passwd` file is writable by a group-owner or the world the risk of its compromise is increased. The file contains the list of accounts on the system and associated information, and protection of this file is critical for system security.

Severity: medium

Identifiers: CCE-26887-0

References: AC-6, http://iase.disa.mil/stigs/cci/Pages/index.aspx, Req-8.7.c

Remediation Shell script: (show)

Complexity: | low
Disruption: | low
Reboot: | false
Strategy: | disable

    chmod 0644 /etc/passwd

### 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.

contains 4 rules

#### Verify that Shared Library Files Have Restrictive Permissions [ref]rule

System-wide shared library files, which are linked to executables during process load time or run time, are stored in the following directories by default:

    /lib
    /lib64
    /usr/lib
    /usr/lib64

Kernel modules, which can be added to the kernel during runtime, are stored in `/lib/modules`. All files in these directories should not be group-writable or world-writable. If any file in these directories is found to be group-writable or world-writable, correct its permission with the following command:

    $ sudo chmod go-w FILE

Rationale:

Files from shared library directories are loaded into the address space of processes (including privileged ones) or of the kernel itself at runtime. Restrictive permissions are necessary to protect the integrity of the system.

Severity: medium

Identifiers: CCE-26966-2

References: AC-6, http://iase.disa.mil/stigs/cci/Pages/index.aspx

Remediation Shell script: (show)

Complexity: | low
Disruption: | low
Reboot: | false
Strategy: | disable

    DIRS="/lib /lib64 /usr/lib /usr/lib64"
    for dirPath in $DIRS; do
    	find "$dirPath" -perm /022 -type f -exec chmod go-w '{}' \;
    done

#### Verify that Shared Library Files Have Root Ownership [ref]rule

System-wide shared library files, which are linked to executables during process load time or run time, are stored in the following directories by default:

    /lib
    /lib64
    /usr/lib
    /usr/lib64

Kernel modules, which can be added to the kernel during runtime, are also stored in `/lib/modules`. All files in these directories should be owned by the `root` user. If the directory, or any file in these directories, is found to be owned by a user other than root correct its ownership with the following command:

    $ sudo chown root FILE

Rationale:

Files from shared library directories are loaded into the address space of processes (including privileged ones) or of the kernel itself at runtime. Proper ownership is necessary to protect the integrity of the system.

Severity: medium

Identifiers: CCE-26648-6

References: AC-6, http://iase.disa.mil/stigs/cci/Pages/index.aspx

Remediation Shell script: (show)

Complexity: | low
Disruption: | low
Reboot: | false
Strategy: | disable

    for LIBDIR in /usr/lib /usr/lib64 /lib /lib64
    do
      if [ -d $LIBDIR ]
      then
        find -L $LIBDIR \! -user root -exec chown root {} \;
      fi
    done

#### Verify that System Executables Have Restrictive Permissions [ref]rule

System executables are stored in the following directories by default:

    /bin
    /sbin
    /usr/bin
    /usr/libexec
    /usr/local/bin
    /usr/local/sbin
    /usr/sbin

All files in these directories should not be group-writable or world-writable. If any file FILE in these directories is found to be group-writable or world-writable, correct its permission with the following command:

    $ sudo chmod go-w FILE

Rationale:

System binaries are executed by privileged users, as well as system services, and restrictive permissions are necessary to ensure execution of these programs cannot be co-opted.

Severity: medium

Identifiers: CCE-27075-1

References: AC-6, http://iase.disa.mil/stigs/cci/Pages/index.aspx

Remediation Shell script: (show)

Complexity: | low
Disruption: | low
Reboot: | false
Strategy: | disable

    DIRS="/bin /usr/bin /usr/local/bin /sbin /usr/sbin /usr/local/sbin /usr/libexec"
    for dirPath in $DIRS; do
    	find "$dirPath" -perm /022 -exec chmod go-w '{}' \;
    done

#### Verify that System Executables Have Root Ownership [ref]rule

System executables are stored in the following directories by default:

    /bin
    /sbin
    /usr/bin
    /usr/libexec
    /usr/local/bin
    /usr/local/sbin
    /usr/sbin

All files in these directories should be owned by the `root` user. If any file FILE in these directories is found to be owned by a user other than root, correct its ownership with the following command:

    $ sudo chown root FILE

Rationale:

System binaries are executed by privileged users as well as system services, and restrictive permissions are necessary to ensure that their execution of these programs cannot be co-opted.

Severity: medium

Identifiers: CCE-27119-7

References: AC-6, http://iase.disa.mil/stigs/cci/Pages/index.aspx

Remediation Shell script: (show)

Complexity: | low
Disruption: | low
Reboot: | false
Strategy: | disable

    find /bin/ \
    /usr/bin/ \
    /usr/local/bin/ \
    /sbin/ \
    /usr/sbin/ \
    /usr/local/sbin/ \
    /usr/libexec \
    \! -user root -execdir chown root {} \;

### 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 7, 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.
For more information on SELinux, see https://access.redhat.com/documentation/en-US/Red_Hat_Enterprise_Linux/7/html/SELinux_Users_and_Administrators_Guide

contains 2 rules

#### Ensure SELinux State is Enforcing [ref]rule

The SELinux state should be set to `enforcing` at system boot time. In the file `/etc/selinux/config`, add or correct the following line to configure the system to boot into enforcing mode:

    SELINUX=enforcing

Rationale:

Setting the SELinux state to enforcing ensures SELinux is able to confine potentially compromised processes to the security policy, which is designed to prevent them from causing damage to the system or further elevating their privileges.

Severity: high

Identifiers: CCE-27334-2

References: AC-3, AC-3(3), AC-3(4), AC-4, AC-6, AU-9, SI-6(a), 2165, 2696, 1.4.2, SRG-OS-000445-GPOS-00199, RHEL-07-020210

Remediation Shell script: (show)

Complexity: | low
Disruption: | low
Reboot: | false
Strategy: | disable

    var_selinux_state="enforcing"

    function replace_or_append {
      local config_file=$1
      local key=$2
      local value=$3
      local cce=$4
      local format=$5

      # Check sanity of the input
      if [ $# -lt "3" ]
      then
            echo "Usage: replace_or_append 'config_file_location' 'key_to_search' 'new_value'"
            echo
            echo "If symlinks need to be taken into account, add yes/no to the last argument"
            echo "to allow to 'follow_symlinks'."
            echo "Aborting."
            exit 1
      fi

      # Test if the config_file is a symbolic link. If so, use --follow-symlinks with sed.
      # Otherwise, regular sed command will do.
      if test -L $config_file; then
        sed_command="sed -i --follow-symlinks"
      else
        sed_command="sed -i"
      fi

      # Test that the cce arg is not empty or does not equal $CCENUM.
      # If $CCENUM exists, it means that there is no CCE assigned.
      if ! [ "x$cce" = x ] && [ "$cce" != '$CCENUM' ]; then
        cce="CCE-${cce}"
      else
        cce="CCE"
      fi

      # Strip any search characters in the key arg so that the key can be replaced without
      # adding any search characters to the config file.
      stripped_key=$(sed "s/[\^=\$,;+]*//g" <<< $key)

      # If there is no print format specified in the last arg, use the default format.
      if ! [ "x$format" = x ] ; then
        printf -v formatted_output "$format" $stripped_key $value
      else
        formatted_output="$stripped_key = $value"
      fi

      # If the key exists, change it. Otherwise, add it to the config_file.
      if `grep -qi $key $config_file` ; then
        $sed_command "s/$key.*/$formatted_output/g" $config_file
      else
        echo -ne "\n# Per $cce: Set $formatted_output in $config_file" >> $config_file
        echo -ne "\n$formatted_output" >> $config_file
      fi

    }

    replace_or_append '/etc/sysconfig/selinux' '^SELINUX=' $var_selinux_state 'CCE-27334-2' '%s=%s'

#### Configure SELinux Policy [ref]rule

The SELinux `targeted` policy is appropriate for general-purpose desktops and servers, as well as systems in many other roles. To configure the system to use this policy, add or correct the following line in `/etc/selinux/config`:

    SELINUXTYPE=targeted

Other policies, such as `mls`, provide additional security labeling and greater confinement but are not compatible with many general-purpose use cases. Rationale:

Setting the SELinux policy to `targeted` or a more specialized policy ensures the system will confine processes that are likely to be targeted for exploitation, such as network or system services.
Note: During the development or debugging of SELinux modules, it is common to temporarily place non-production systems in `permissive` mode. In such temporary cases, SELinux policies should be developed, and once work is completed, the system should be reconfigured to `targeted`.

Severity: high

Identifiers: CCE-27279-9

References: AC-3, AC-3(3), AC-3(4), AC-4, AC-6, AU-9, SI-6(a), 2696, 1.4.3, SRG-OS-000445-GPOS-00199, RHEL-07-020211

Remediation Shell script: (show)

Complexity: | low
Disruption: | low
Reboot: | false
Strategy: | disable

    var_selinux_policy_name="targeted"

    function replace_or_append {
      local config_file=$1
      local key=$2
      local value=$3
      local cce=$4
      local format=$5

      # Check sanity of the input
      if [ $# -lt "3" ]
      then
            echo "Usage: replace_or_append 'config_file_location' 'key_to_search' 'new_value'"
            echo
            echo "If symlinks need to be taken into account, add yes/no to the last argument"
            echo "to allow to 'follow_symlinks'."
            echo "Aborting."
            exit 1
      fi

      # Test if the config_file is a symbolic link. If so, use --follow-symlinks with sed.
      # Otherwise, regular sed command will do.
      if test -L $config_file; then
        sed_command="sed -i --follow-symlinks"
      else
        sed_command="sed -i"
      fi

      # Test that the cce arg is not empty or does not equal $CCENUM.
      # If $CCENUM exists, it means that there is no CCE assigned.
      if ! [ "x$cce" = x ] && [ "$cce" != '$CCENUM' ]; then
        cce="CCE-${cce}"
      else
        cce="CCE"
      fi

      # Strip any search characters in the key arg so that the key can be replaced without
      # adding any search characters to the config file.
      stripped_key=$(sed "s/[\^=\$,;+]*//g" <<< $key)

      # If there is no print format specified in the last arg, use the default format.
      if ! [ "x$format" = x ] ; then
        printf -v formatted_output "$format" $stripped_key $value
      else
        formatted_output="$stripped_key = $value"
      fi

      # If the key exists, change it. Otherwise, add it to the config_file.
      if `grep -qi $key $config_file` ; then
        $sed_command "s/$key.*/$formatted_output/g" $config_file
      else
        echo -ne "\n# Per $cce: Set $formatted_output in $config_file" >> $config_file
        echo -ne "\n$formatted_output" >> $config_file
      fi

    }

    replace_or_append '/etc/sysconfig/selinux' '^SELINUXTYPE=' $var_selinux_policy_name 'CCE-27279-9' '%s=%s'

### 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 7.

contains 23 rules

### 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.

contains 7 rules

### 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.

contains 2 rules

#### Ensure that System Accounts Do Not Run a Shell Upon Login [ref]rule

Some accounts are not associated with a human user of the system, and exist to perform some administrative function. Should an attacker be able to log into these accounts, they should not be granted access to a shell.
The login shell for each local account is stored in the last field of each line in `/etc/passwd`. System accounts are those user accounts with a user ID less than UID_MIN, where value of UID_MIN directive is set in /etc/login.defs configuration file. In the default configuration UID_MIN is set to 1000, thus system accounts are those user accounts with a user ID less than 1000. The user ID is stored in the third field. If any system account SYSACCT (other than root) has a login shell, disable it with the command:

    $ sudo usermod -s /sbin/nologin SYSACCT

Warning: Do not perform the steps in this section on the root account. Doing so might cause the system to become inaccessible.
Rationale:

Ensuring shells are not given to system accounts upon login makes it more difficult for attackers to make use of system accounts.

Severity: medium

Identifiers: CCE-26448-1

References: AC-2, http://iase.disa.mil/stigs/cci/Pages/index.aspx

#### Verify Only Root Has UID 0 [ref]rule

If any account other than root has a UID of 0, this misconfiguration should be investigated and the accounts other than root should be removed or have their UID changed.
If the account is associated with system commands or applications the UID should be changed to one greater than "0" but less than "1000." Otherwise assign a UID greater than "1000" that has not already been assigned.

Rationale:

An account has root authority if it has a UID of 0. Multiple accounts with a UID of 0 afford more opportunity for potential intruders to guess a password for a privileged account. Proper configuration of sudo is recommended to afford multiple system administrators access to root privileges in an accountable manner.

Severity: high

Identifiers: CCE-27175-9

References: AC-6, IA-2(1), IA-4, 366, SRG-OS-000480-GPOS-00227, RHEL-07-020310

Remediation Shell script: (show)

Complexity: | low
Disruption: | low
Reboot: | false
Strategy: | disable

    awk -F: '$3 == 0 && $1 != "root" { print $1 }' /etc/passwd | xargs passwd -l

### 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.

contains 2 rules

#### Prevent Log In to Accounts With Empty Password [ref]rule

If an account is configured for password authentication but does not have an assigned password, it may be possible to log into the account without authentication. Remove any instances of the `nullok` option in `/etc/pam.d/system-auth` to prevent logins with empty passwords.

Rationale:

If an account has an empty password, anyone could log in and run commands with the privileges of that account. Accounts with empty passwords should never be used in operational environments.

Severity: high

Identifiers: CCE-27286-4

References: AC-6, IA-5(b), IA-5(c), IA-5(1)(a), 366, SRG-OS-000480-GPOS-00227, RHEL-07-010260, Req-8.2.3

Remediation Shell script: (show)

Complexity: | low
Disruption: | low
Reboot: | false
Strategy: | disable

    sed --follow-symlinks -i 's/\<nullok\>//g' /etc/pam.d/system-auth

#### Verify All Account Password Hashes are Shadowed [ref]rule

If any password hashes are stored in `/etc/passwd` (in the second field, instead of an `x`), the cause of this misconfiguration should be investigated. The account should have its password reset and the hash should be properly stored, or the account should be deleted entirely.

Rationale:

The hashes for all user account passwords should be stored in the file `/etc/shadow` and never in `/etc/passwd`, which is readable by all users.

Severity: medium

Identifiers: CCE-27352-4

References: IA-5(h), http://iase.disa.mil/stigs/cci/Pages/index.aspx, Req-8.2.1

### 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

contains 3 rules

#### Set Password Minimum Length in login.defs [ref]rule

To specify password length requirements for new accounts, edit the file `/etc/login.defs` and add or correct the following lines:

    PASS_MIN_LEN 14

The DoD requirement is `15`. The FISMA requirement is `12`. If a program consults `/etc/login.defs` and also another PAM module (such as `pam_pwquality`) during a password change operation, then the most restrictive must be satisfied. See PAM section for more information about enforcing password quality requirements. Rationale:

Requiring a minimum password length makes password cracking attacks more difficult by ensuring a larger search space. However, any security benefit from an onerous requirement must be carefully weighed against usability problems, support costs, or counterproductive behavior that may result.

Severity: medium

Identifiers: CCE-27123-9

References: IA-5(f), IA-5(1)(a), http://iase.disa.mil/stigs/cci/Pages/index.aspx

Remediation Shell script: (show)

Complexity: | low
Disruption: | low
Reboot: | false
Strategy: | disable

    var_accounts_password_minlen_login_defs="6"

    grep -q ^PASS_MIN_LEN /etc/login.defs && \
      sed -i "s/PASS_MIN_LEN.*/PASS_MIN_LEN     $var_accounts_password_minlen_login_defs/g" /etc/login.defs
    if ! [ $? -eq 0 ]; then
        echo "PASS_MIN_LEN      $var_accounts_password_minlen_login_defs" >> /etc/login.defs
    fi

#### Set Password Minimum Age [ref]rule

To specify password minimum age for new accounts, edit the file `/etc/login.defs` and add or correct the following line, replacing DAYS appropriately:

    PASS_MIN_DAYS DAYS

A value of 1 day is considered for sufficient for many environments. The DoD requirement is 1. Rationale:

Enforcing a minimum password lifetime helps to prevent repeated password changes to defeat the password reuse or history enforcement requirement. If users are allowed to immediately and continually change their password, then the password could be repeatedly changed in a short period of time to defeat the organization's policy regarding password reuse.
Setting the minimum password age protects against users cycling back to a favorite password after satisfying the password reuse requirement.

Severity: medium

Identifiers: CCE-27002-5

References: IA-5(f), IA-5(1)(d), 198, SRG-OS-000075-GPOS-00043, RHEL-07-010200

Remediation Shell script: (show)

Complexity: | low
Disruption: | low
Reboot: | false
Strategy: | disable

    var_accounts_minimum_age_login_defs="7"

    grep -q ^PASS_MIN_DAYS /etc/login.defs && \
      sed -i "s/PASS_MIN_DAYS.*/PASS_MIN_DAYS     $var_accounts_minimum_age_login_defs/g" /etc/login.defs
    if ! [ $? -eq 0 ]; then
        echo "PASS_MIN_DAYS      $var_accounts_minimum_age_login_defs" >> /etc/login.defs
    fi

#### Set Password Warning Age [ref]rule

To specify how many days prior to password expiration that a warning will be issued to users, edit the file `/etc/login.defs` and add or correct the following line, replacing DAYS appropriately:

    PASS_WARN_AGE DAYS

The DoD requirement is 7. Rationale:

Setting the password warning age enables users to make the change at a practical time.

Severity: low

Identifiers: CCE-26486-1

References: AC-2(2), IA-5(f)

Remediation Shell script: (show)

Complexity: | low
Disruption: | low
Reboot: | false
Strategy: | disable

    var_accounts_password_warn_age_login_defs="7"

    grep -q ^PASS_WARN_AGE /etc/login.defs && \
      sed -i "s/PASS_WARN_AGE.*/PASS_WARN_AGE     $var_accounts_password_warn_age_login_defs/g" /etc/login.defs
    if ! [ $? -eq 0 ]; then
        echo "PASS_WARN_AGE      $var_accounts_password_warn_age_login_defs" >> /etc/login.defs
    fi

### 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.

Warning: Be careful when making changes to PAM's configuration files. The syntax for these files is complex, and modifications can have unexpected consequences. The default configurations shipped with applications should be sufficient for most users.
Warning: Running `authconfig` or `system-config-authentication` will re-write the PAM configuration files, destroying any manually made changes and replacing them with a series of system defaults. One reference to the configuration file syntax can be found at http://www.kernel.org/pub/linux/libs/pam/Linux-PAM-html/sag-configuration-file.html .

contains 11 rules

### Set Password Quality Requirements [ref]group

The default `pam_pwquality` 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 `pam_pwquality` module is the preferred way of configuring password requirements.
The `pam_cracklib` PAM module can also provide strength checking for passwords as the `pam_pwquality` module. 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 pages `pam_pwquality(8)` and `pam_cracklib(8)` provide information on the capabilities and configuration of each.

contains 6 rules

### Set Password Quality Requirements with pam_pwquality [ref]group

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

    password    requisite     pam_pwquality.so try_first_pass local_users_only retry=3 authtok_type=

If no such line exists, add one as the first line of the password section in `/etc/pam.d/system-auth`. Next, modify the settings in `/etc/security/pwquality.conf` to match the following:

    difok = 4
    minlen = 14
    dcredit = -1
    ucredit = -1
    lcredit = -1
    ocredit = -1
    maxrepeat = 3

The arguments can be modified to ensure compliance with your organization's security policy. Discussion of each parameter follows.
Warning: Note that the password quality requirements are not enforced for the root account for some reason.

contains 6 rules

#### Set Password Retry Prompts Permitted Per-Session [ref]rule

To configure the number of retry prompts that are permitted per-session:
Edit the `pam_pwquality.so` statement in `/etc/pam.d/system-auth` to show `retry=3`, or a lower value if site policy is more restrictive.
The DoD requirement is a maximum of 3 prompts per session.

Rationale:

Setting the password retry prompts that are permitted on a per-session basis to a low value requires some software, such as SSH, to re-connect. This can slow down and draw additional attention to some types of password-guessing attacks. Note that this is different from account lockout, which is provided by the pam_faillock module.

Severity: low

Identifiers: CCE-27160-1

References: CM-6(b), IA-5(c), 366, 6.3.2, SRG-OS-000480-GPOS-00225, RHEL-07-010410

Remediation Shell script: (show)

Complexity: | low
Disruption: | low
Reboot: | false
Strategy: | disable

    var_password_pam_retry="3"

    if grep -q "retry=" /etc/pam.d/system-auth; then
    	sed -i --follow-symlinks "s/\(retry *= *\).*/\1$var_password_pam_retry/" /etc/pam.d/system-auth
    else
    	sed -i --follow-symlinks "/pam_pwquality.so/ s/$/ retry=$var_password_pam_retry/" /etc/pam.d/system-auth
    fi

#### Set Password Strength Minimum Digit Characters [ref]rule

The pam_pwquality module's `dcredit` parameter controls requirements for usage of digits in a password. When set to a negative number, any password will be required to contain that many digits. When set to a positive number, pam_pwquality will grant +1 additional length credit for each digit. Modify the `dcredit` setting in `/etc/security/pwquality.conf` to require the use of a digit in passwords.

Rationale:

Use of a complex password helps to increase the time and resources required to compromise the password. Password complexity, or strength, is a measure of the effectiveness of a password in resisting attempts at guessing and brute-force attacks. Password complexity is one factor of several that determines how long it takes to crack a password. The more complex the password, the greater the number of possble combinations that need to be tested before the password is compromised. Requiring digits makes password guessing attacks more difficult by ensuring a larger search space.

Severity: medium

Identifiers: CCE-27214-6

References: IA-5(1)(a), IA-5(b), IA-5(c), 194, 194, SRG-OS-000071-GPOS-00039, Req-8.2.3, 6.3.2, RHEL-07-010110

Remediation Shell script: (show)

Complexity: | low
Disruption: | low
Reboot: | false
Strategy: | configure

    var_password_pam_dcredit="-1"

    function replace_or_append {
      local config_file=$1
      local key=$2
      local value=$3
      local cce=$4
      local format=$5

      # Check sanity of the input
      if [ $# -lt "3" ]
      then
            echo "Usage: replace_or_append 'config_file_location' 'key_to_search' 'new_value'"
            echo
            echo "If symlinks need to be taken into account, add yes/no to the last argument"
            echo "to allow to 'follow_symlinks'."
            echo "Aborting."
            exit 1
      fi

      # Test if the config_file is a symbolic link. If so, use --follow-symlinks with sed.
      # Otherwise, regular sed command will do.
      if test -L $config_file; then
        sed_command="sed -i --follow-symlinks"
      else
        sed_command="sed -i"
      fi

      # Test that the cce arg is not empty or does not equal $CCENUM.
      # If $CCENUM exists, it means that there is no CCE assigned.
      if ! [ "x$cce" = x ] && [ "$cce" != '$CCENUM' ]; then
        cce="CCE-${cce}"
      else
        cce="CCE"
      fi

      # Strip any search characters in the key arg so that the key can be replaced without
      # adding any search characters to the config file.
      stripped_key=$(sed "s/[\^=\$,;+]*//g" <<< $key)

      # If there is no print format specified in the last arg, use the default format.
      if ! [ "x$format" = x ] ; then
        printf -v formatted_output "$format" $stripped_key $value
      else
        formatted_output="$stripped_key = $value"
      fi

      # If the key exists, change it. Otherwise, add it to the config_file.
      if `grep -qi $key $config_file` ; then
        $sed_command "s/$key.*/$formatted_output/g" $config_file
      else
        echo -ne "\n# Per $cce: Set $formatted_output in $config_file" >> $config_file
        echo -ne "\n$formatted_output" >> $config_file
      fi

    }

    replace_or_append '/etc/security/pwquality.conf' '^dcredit' $var_password_pam_dcredit 'CCE-27214-6' '%s = %s'

#### Set Password Strength Minimum Uppercase Characters [ref]rule

The pam_pwquality module's `ucredit=` parameter controls requirements for usage of uppercase letters in a password. When set to a negative number, any password will be required to contain that many uppercase characters. When set to a positive number, pam_pwquality will grant +1 additional length credit for each uppercase character. Modify the `ucredit` setting in `/etc/security/pwquality.conf` to require the use of an uppercase character in passwords.

Rationale:

Use of a complex password helps to increase the time and resources reuiqred to compromise the password. Password complexity, or strength, is a measure of the effectiveness of a password in resisting attempts at guessing and brute-force attacks.
Password complexity is one factor of several that determines how long it takes to crack a password. The more complex the password, the greater the number of possible combinations that need to be tested before the password is compromised.

Severity: medium

Identifiers: CCE-27200-5

References: IA-5(b), IA-5(c), IA-5(1)(a), 192, SRG-OS-000069-GPOS-00037, RHEL-07-010090, Req-8.2.3, 6.3.2

Remediation Shell script: (show)

Complexity: | low
Disruption: | low
Reboot: | false
Strategy: | disable

    var_password_pam_ucredit="-2"

    function replace_or_append {
      local config_file=$1
      local key=$2
      local value=$3
      local cce=$4
      local format=$5

      # Check sanity of the input
      if [ $# -lt "3" ]
      then
            echo "Usage: replace_or_append 'config_file_location' 'key_to_search' 'new_value'"
            echo
            echo "If symlinks need to be taken into account, add yes/no to the last argument"
            echo "to allow to 'follow_symlinks'."
            echo "Aborting."
            exit 1
      fi

      # Test if the config_file is a symbolic link. If so, use --follow-symlinks with sed.
      # Otherwise, regular sed command will do.
      if test -L $config_file; then
        sed_command="sed -i --follow-symlinks"
      else
        sed_command="sed -i"
      fi

      # Test that the cce arg is not empty or does not equal $CCENUM.
      # If $CCENUM exists, it means that there is no CCE assigned.
      if ! [ "x$cce" = x ] && [ "$cce" != '$CCENUM' ]; then
        cce="CCE-${cce}"
      else
        cce="CCE"
      fi

      # Strip any search characters in the key arg so that the key can be replaced without
      # adding any search characters to the config file.
      stripped_key=$(sed "s/[\^=\$,;+]*//g" <<< $key)

      # If there is no print format specified in the last arg, use the default format.
      if ! [ "x$format" = x ] ; then
        printf -v formatted_output "$format" $stripped_key $value
      else
        formatted_output="$stripped_key = $value"
      fi

      # If the key exists, change it. Otherwise, add it to the config_file.
      if `grep -qi $key $config_file` ; then
        $sed_command "s/$key.*/$formatted_output/g" $config_file
      else
        echo -ne "\n# Per $cce: Set $formatted_output in $config_file" >> $config_file
        echo -ne "\n$formatted_output" >> $config_file
      fi

    }

    replace_or_append '/etc/security/pwquality.conf' '^ucredit' $var_password_pam_ucredit 'CCE-27200-5' '%s = %s'

#### Set Password Strength Minimum Special Characters [ref]rule

The pam_pwquality module's `ocredit=` parameter controls requirements for usage of special (or "other") characters in a password. When set to a negative number, any password will be required to contain that many special characters. When set to a positive number, pam_pwquality will grant +1 additional length credit for each special character. Modify the `ocredit` setting in `/etc/security/pwquality.conf` to equal -2 to require use of a special character in passwords.

Rationale:

Use of a complex password helps to increase the time and resources required to compromise the password. Password complexity, or strength, is a measure of the effectiveness of a password in resisting attempts at guessing and brute-force attacks.
Password complexity is one factor of several that determines how long it takes to crack a password. The more complex the password, the greater the number of possble combinations that need to be tested before the password is compromised. Requiring a minimum number of special characters makes password guessing attacks more difficult by ensuring a larger search space.

Severity: medium

Identifiers: CCE-27360-7

References: IA-5(b), IA-5(c), IA-5(1)(a), 1619, SRG-OS-000266-GPOS-00101, RHEL-07-010120

Remediation Shell script: (show)

Complexity: | low
Disruption: | low
Reboot: | false
Strategy: | disable

    var_password_pam_ocredit="-2"

    function replace_or_append {
      local config_file=$1
      local key=$2
      local value=$3
      local cce=$4
      local format=$5

      # Check sanity of the input
      if [ $# -lt "3" ]
      then
            echo "Usage: replace_or_append 'config_file_location' 'key_to_search' 'new_value'"
            echo
            echo "If symlinks need to be taken into account, add yes/no to the last argument"
            echo "to allow to 'follow_symlinks'."
            echo "Aborting."
            exit 1
      fi

      # Test if the config_file is a symbolic link. If so, use --follow-symlinks with sed.
      # Otherwise, regular sed command will do.
      if test -L $config_file; then
        sed_command="sed -i --follow-symlinks"
      else
        sed_command="sed -i"
      fi

      # Test that the cce arg is not empty or does not equal $CCENUM.
      # If $CCENUM exists, it means that there is no CCE assigned.
      if ! [ "x$cce" = x ] && [ "$cce" != '$CCENUM' ]; then
        cce="CCE-${cce}"
      else
        cce="CCE"
      fi

      # Strip any search characters in the key arg so that the key can be replaced without
      # adding any search characters to the config file.
      stripped_key=$(sed "s/[\^=\$,;+]*//g" <<< $key)

      # If there is no print format specified in the last arg, use the default format.
      if ! [ "x$format" = x ] ; then
        printf -v formatted_output "$format" $stripped_key $value
      else
        formatted_output="$stripped_key = $value"
      fi

      # If the key exists, change it. Otherwise, add it to the config_file.
      if `grep -qi $key $config_file` ; then
        $sed_command "s/$key.*/$formatted_output/g" $config_file
      else
        echo -ne "\n# Per $cce: Set $formatted_output in $config_file" >> $config_file
        echo -ne "\n$formatted_output" >> $config_file
      fi

    }

    replace_or_append '/etc/security/pwquality.conf' '^ocredit' $var_password_pam_ocredit 'CCE-27360-7' '%s = %s'

#### Set Password Strength Minimum Lowercase Characters [ref]rule

The pam_pwquality module's `lcredit` parameter controls requirements for usage of lowercase letters in a password. When set to a negative number, any password will be required to contain that many lowercase characters. When set to a positive number, pam_pwquality will grant +1 additional length credit for each lowercase character. Modify the `lcredit` setting in `/etc/security/pwquality.conf` to require the use of a lowercase character in passwords.

Rationale:

Use of a complex password helps to increase the time and resources required to compromise the password. Password complexity, or strength, is a measure of the effectiveness of a password in resisting attempts at guessing and brute-force attacks.
Password complexity is one factor of several that determines how long it takes to crack a password. The more complex the password, the greater the number of possble combinations that need to be tested before the password is compromised. Requiring a minimum number of lowercase characters makes password guessing attacks more difficult by ensuring a larger search space.

Severity: medium

Identifiers: CCE-27345-8

References: IA-5(b), IA-5(c), IA-5(1)(a), 193, SRG-OS-000070-GPOS-00038, Req-8.2.3, RHEL-07-010100

Remediation Shell script: (show)

Complexity: | low
Disruption: | low
Reboot: | false
Strategy: | disable

    var_password_pam_lcredit="-2"

    function replace_or_append {
      local config_file=$1
      local key=$2
      local value=$3
      local cce=$4
      local format=$5

      # Check sanity of the input
      if [ $# -lt "3" ]
      then
            echo "Usage: replace_or_append 'config_file_location' 'key_to_search' 'new_value'"
            echo
            echo "If symlinks need to be taken into account, add yes/no to the last argument"
            echo "to allow to 'follow_symlinks'."
            echo "Aborting."
            exit 1
      fi

      # Test if the config_file is a symbolic link. If so, use --follow-symlinks with sed.
      # Otherwise, regular sed command will do.
      if test -L $config_file; then
        sed_command="sed -i --follow-symlinks"
      else
        sed_command="sed -i"
      fi

      # Test that the cce arg is not empty or does not equal $CCENUM.
      # If $CCENUM exists, it means that there is no CCE assigned.
      if ! [ "x$cce" = x ] && [ "$cce" != '$CCENUM' ]; then
        cce="CCE-${cce}"
      else
        cce="CCE"
      fi

      # Strip any search characters in the key arg so that the key can be replaced without
      # adding any search characters to the config file.
      stripped_key=$(sed "s/[\^=\$,;+]*//g" <<< $key)

      # If there is no print format specified in the last arg, use the default format.
      if ! [ "x$format" = x ] ; then
        printf -v formatted_output "$format" $stripped_key $value
      else
        formatted_output="$stripped_key = $value"
      fi

      # If the key exists, change it. Otherwise, add it to the config_file.
      if `grep -qi $key $config_file` ; then
        $sed_command "s/$key.*/$formatted_output/g" $config_file
      else
        echo -ne "\n# Per $cce: Set $formatted_output in $config_file" >> $config_file
        echo -ne "\n$formatted_output" >> $config_file
      fi

    }

    replace_or_append '/etc/security/pwquality.conf' '^lcredit' $var_password_pam_lcredit 'CCE-27345-8' '%s = %s'

#### Set Password Strength Minimum Different Characters [ref]rule

The pam_pwquality module's `difok` parameter sets the number of characters in a password that must not be present in and old password during a password change. Modify the `difok` setting in `/etc/security/pwquality.conf` to equal 3 to require differing characters when changing passwords.

Rationale:

Use of a complex password helps to increase the time and resources required to compromise the password. Password complexity, or strength, is a measure of the effectiveness of a password in resisting attempts at guessing and brute–force attacks.
Password complexity is one factor of several that determines how long it takes to crack a password. The more complex the password, the greater the number of possible combinations that need to be tested before the password is compromised.
Requiring a minimum number of different characters during password changes ensures that newly changed passwords should not resemble previously compromised ones. Note that passwords which are changed on compromised systems will still be compromised, however.

Severity: medium

Identifiers: CCE-26631-2

References: IA-5(b), IA-5(c), IA-5(1)(b), 195, SRG-OS-000072-GPOS-00040, RHEL-07-010130

Remediation Shell script: (show)

Complexity: | low
Disruption: | medium
Reboot: | true
Strategy: | disable

    var_password_pam_difok="3"

    function replace_or_append {
      local config_file=$1
      local key=$2
      local value=$3
      local cce=$4
      local format=$5

      # Check sanity of the input
      if [ $# -lt "3" ]
      then
            echo "Usage: replace_or_append 'config_file_location' 'key_to_search' 'new_value'"
            echo
            echo "If symlinks need to be taken into account, add yes/no to the last argument"
            echo "to allow to 'follow_symlinks'."
            echo "Aborting."
            exit 1
      fi

      # Test if the config_file is a symbolic link. If so, use --follow-symlinks with sed.
      # Otherwise, regular sed command will do.
      if test -L $config_file; then
        sed_command="sed -i --follow-symlinks"
      else
        sed_command="sed -i"
      fi

      # Test that the cce arg is not empty or does not equal $CCENUM.
      # If $CCENUM exists, it means that there is no CCE assigned.
      if ! [ "x$cce" = x ] && [ "$cce" != '$CCENUM' ]; then
        cce="CCE-${cce}"
      else
        cce="CCE"
      fi

      # Strip any search characters in the key arg so that the key can be replaced without
      # adding any search characters to the config file.
      stripped_key=$(sed "s/[\^=\$,;+]*//g" <<< $key)

      # If there is no print format specified in the last arg, use the default format.
      if ! [ "x$format" = x ] ; then
        printf -v formatted_output "$format" $stripped_key $value
      else
        formatted_output="$stripped_key = $value"
      fi

      # If the key exists, change it. Otherwise, add it to the config_file.
      if `grep -qi $key $config_file` ; then
        $sed_command "s/$key.*/$formatted_output/g" $config_file
      else
        echo -ne "\n# Per $cce: Set $formatted_output in $config_file" >> $config_file
        echo -ne "\n$formatted_output" >> $config_file
      fi

    }

    replace_or_append '/etc/security/pwquality.conf' '^difok' $var_password_pam_difok 'CCE-26631-2' '%s = %s'

### 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`.

Warning: Locking out user accounts presents the risk of a denial-of-service attack. The lockout policy must weigh whether the risk of such a denial-of-service attack outweighs the benefits of thwarting password guessing attacks.

contains 2 rules

#### Set Deny For Failed Password Attempts [ref]rule

To configure the system to lock out accounts after a number of incorrect login attempts using `pam_faillock.so`, modify the content of both `/etc/pam.d/system-auth` and `/etc/pam.d/password-auth` as follows:

- add the following line immediately `before` the `pam_unix.so` statement in the `AUTH` section:

      auth required pam_faillock.so preauth silent deny=5 unlock_time=604800 fail_interval=900

- add the following line immediately `after` the `pam_unix.so` statement in the `AUTH` section:

      auth [default=die] pam_faillock.so authfail deny=5 unlock_time=604800 fail_interval=900

- add the following line immediately `before` the `pam_unix.so` statement in the `ACCOUNT` section:

      account required pam_faillock.so

Rationale:

Locking out user accounts after a number of incorrect attempts prevents direct password guessing attacks.

Severity: medium

Identifiers: CCE-27350-8

References: AC-7(b), 2238, SRG-OS-000329-GPOS-00128, SRG-OS-000021-GPOS-00005, RHEL-07-010371, Req-8.1.6, 6.3.3

Remediation Shell script: (show)

Complexity: | low
Disruption: | low
Reboot: | false
Strategy: | disable

    var_accounts_passwords_pam_faillock_deny="5"

    AUTH_FILES[0]="/etc/pam.d/system-auth"
    AUTH_FILES[1]="/etc/pam.d/password-auth"

    for pamFile in "${AUTH_FILES[@]}"
    do

    	# pam_faillock.so already present?
    	if grep -q "^auth.*pam_faillock.so.*" $pamFile; then

    		# pam_faillock.so present, deny directive present?
    		if grep -q "^auth.*[default=die].*pam_faillock.so.*authfail.*deny=" $pamFile; then

    			# both pam_faillock.so & deny present, just correct deny directive value
    			sed -i --follow-symlinks "s/\(^auth.*required.*pam_faillock.so.*preauth.*silent.*\)\(deny *= *\).*/\1\2$var_accounts_passwords_pam_faillock_deny/" $pamFile
    			sed -i --follow-symlinks "s/\(^auth.*[default=die].*pam_faillock.so.*authfail.*\)\(deny *= *\).*/\1\2$var_accounts_passwords_pam_faillock_deny/" $pamFile

    		# pam_faillock.so present, but deny directive not yet
    		else

    			# append correct deny value to appropriate places
    			sed -i --follow-symlinks "/^auth.*required.*pam_faillock.so.*preauth.*silent.*/ s/$/ deny=$var_accounts_passwords_pam_faillock_deny/" $pamFile
    			sed -i --follow-symlinks "/^auth.*[default=die].*pam_faillock.so.*authfail.*/ s/$/ deny=$var_accounts_passwords_pam_faillock_deny/" $pamFile
    		fi

    	# pam_faillock.so not present yet
    	else

    		# insert pam_faillock.so preauth & authfail rows with proper value of the 'deny' option
    		sed -i --follow-symlinks "/^auth.*sufficient.*pam_unix.so.*/i auth        required      pam_faillock.so preauth silent deny=$var_accounts_passwords_pam_faillock_deny" $pamFile
    		sed -i --follow-symlinks "/^auth.*sufficient.*pam_unix.so.*/a auth        [default=die] pam_faillock.so authfail deny=$var_accounts_passwords_pam_faillock_deny" $pamFile
    		sed -i --follow-symlinks "/^account.*required.*pam_unix.so/i account     required      pam_faillock.so" $pamFile
    	fi
    done

#### Limit Password Reuse [ref]rule

Do not allow users to reuse recent passwords. This can be accomplished by using the `remember` option for the `pam_unix` or `pam_pwhistory` PAM modules.
In the file `/etc/pam.d/system-auth`, append `remember=5` to the line which refers to the `pam_unix.so` or `pam_pwhistory.so`module, as shown below:

- for the `pam_unix.so` case:

      password sufficient pam_unix.so ...existing_options... remember=5

- for the `pam_pwhistory.so` case:

      password requisite pam_pwhistory.so ...existing_options... remember=5

The DoD STIG requirement is 5 passwords.Rationale:

Preventing re-use of previous passwords helps ensure that a compromised password is not re-used by a user.

Severity: medium

Identifiers: CCE-26923-3

References: IA-5(f), IA-5(1)(e), 200, SRG-OS-000077-GPOS-00045, RHEL-07-010240, Req-8.2.5, 6.3.4

Remediation Shell script: (show)

Complexity: | low
Disruption: | low
Reboot: | false
Strategy: | disable

    var_password_pam_unix_remember="5"

    if grep -q "remember=" /etc/pam.d/system-auth; then
    	sed -i --follow-symlinks "s/\(^password.*sufficient.*pam_unix.so.*\)\(\(remember *= *\)[^ $]*\)/\1remember=$var_password_pam_unix_remember/" /etc/pam.d/system-auth
    else
    	sed -i --follow-symlinks "/^password[[:space:]]\+sufficient[[:space:]]\+pam_unix.so/ s/$/ remember=$var_password_pam_unix_remember/" /etc/pam.d/system-auth
    fi

### 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.

contains 3 rules

#### Set PAM's Password Hashing Algorithm [ref]rule

The PAM system service can be configured to only store encrypted representations of passwords. In `/etc/pam.d/system-auth`, the `password` section of the file controls which PAM modules execute during a password change. Set the `pam_unix.so` module in the `password` section to include the argument `sha512`, as shown below:

    password    sufficient    pam_unix.so sha512 other arguments...

This will help ensure when local users change their passwords, hashes for the new passwords will be generated using the SHA-512 algorithm. This is the default. Rationale:

Passwords need to be protected at all times, and encryption is the standard method for protecting passwords. If passwords are not encrypted, they can be plainly read (i.e., clear text) and easily compromised. Passwords that are encrypted with a weak algorithm are no more protected than if they are kepy in plain text.
This setting ensures user and group account administration utilities are configured to store only encrypted representations of passwords. Additionally, the `crypt_style` configuration option ensures the use of a strong hashing algorithm that makes password cracking attacks more difficult.

Severity: medium

Identifiers: CCE-27104-9

References: IA-5(b), IA-5(c), IA-5(1)(c), IA-7, 196, SRG-OS-000073-GPOS-00041, RHEL-07-010170, Req-8.2.1, 6.3.1

Remediation Shell script: (show)

Complexity: | low
Disruption: | low
Reboot: | false
Strategy: | disable

    if ! grep -q "^password.*sufficient.*pam_unix.so.*sha512" /etc/pam.d/system-auth; then
    	sed -i --follow-symlinks "/^password.*sufficient.*pam_unix.so/ s/$/ sha512/" /etc/pam.d/system-auth
    fi

#### Set Password Hashing Algorithm in /etc/login.defs [ref]rule

In `/etc/login.defs`, add or correct the following line to ensure the system will use SHA-512 as the hashing algorithm:

    ENCRYPT_METHOD SHA512

Rationale:

Passwords need to be protected at all times, and encryption is the standard method for protecting passwords. If passwords are not encrypted, they can be plainly read (i.e., clear text) and easily compromised. Passwords that are encrypted with a weak algorithm are no more protected than if they are kept in plain text.
Using a stronger hashing algorithm makes password cracking attacks more difficult.

Severity: medium

Identifiers: CCE-27124-7

References: IA-5(b), IA-5(c), IA-5(1)(c), IA-7, 196, SRG-OS-000073-GPOS-00041, RHEL-07-010180, Req-8.2.1, 6.3.1

Remediation Shell script: (show)

Complexity: | low
Disruption: | low
Reboot: | false
Strategy: | disable

    if grep --silent ^ENCRYPT_METHOD /etc/login.defs ; then
    	sed -i 's/^ENCRYPT_METHOD.*/ENCRYPT_METHOD SHA512/g' /etc/login.defs
    else
    	echo "" >> /etc/login.defs
    	echo "ENCRYPT_METHOD SHA512" >> /etc/login.defs
    fi

#### Set Password Hashing Algorithm in /etc/libuser.conf [ref]rule

In `/etc/libuser.conf`, add or correct the following line in its `[defaults]` section to ensure the system will use the SHA-512 algorithm for password hashing:

    crypt_style = sha512

Rationale:

Passwords need to be protected at all times, and encryption is the standard method for protecting passwords. If passwords are not encrypted, they can be plainly read (i.e., clear text) and easily compromised. Passwords that are encrypted with a weak algorithm are no more protected than if they are kepy in plain text.
This setting ensures user and group account administration utilities are configured to store only encrypted representations of passwords. Additionally, the `crypt_style` configuration option ensures the use of a strong hashing algorithm that makes password cracking attacks more difficult.

Severity: medium

Identifiers: CCE-27053-8

References: IA-5(b), IA-5(c), IA-5(1)(c), IA-7, 196, SRG-OS-000073-GPOS-00041, RHEL-07-010190, Req-8.2.1

### 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.

contains 5 rules

### 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 GRUB2. 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.

contains 4 rules

#### Verify /boot/grub2/grub.cfg User Ownership [ref]rule

The file `/boot/grub2/grub.cfg` should be owned by the `root` user to prevent destruction or modification of the file. To properly set the owner of `/boot/grub2/grub.cfg`, run the command:

    $ sudo chown root /boot/grub2/grub.cfg

Rationale:

Only root should be able to modify important boot parameters.

Severity: medium

Identifiers: CCE-26860-7

References: AC-6(7), 225, Req-7.1, 1.5.1

Remediation Shell script: (show)

Complexity: | low
Disruption: | low
Reboot: | false
Strategy: | disable

    chown root /boot/grub2/grub.cfg

#### Verify /boot/grub2/grub.cfg Group Ownership [ref]rule

The file `/boot/grub2/grub.cfg` should be group-owned by the `root` group to prevent destruction or modification of the file. To properly set the group owner of `/boot/grub2/grub.cfg`, run the command:

    $ sudo chgrp root /boot/grub2/grub.cfg

Rationale:

The `root` group is a highly-privileged group. Furthermore, the group-owner of this file should not have any access privileges anyway.

Severity: medium

Identifiers: CCE-26812-8

References: AC-6(7), 225, Req-7.1, 1.5.1

Remediation Shell script: (show)

Complexity: | low
Disruption: | low
Reboot: | false
Strategy: | disable

    chgrp root /boot/grub2/grub.cfg

#### Verify /boot/grub2/grub.cfg Permissions [ref]rule

File permissions for `/boot/grub2/grub.cfg` should be set to 600. To properly set the permissions of `/boot/grub2/grub.cfg`, run the command:

    $ sudo chmod 600 /boot/grub2/grub.cfg

Rationale:

Proper permissions ensure that only the root user can modify important boot parameters.

Severity: medium

Identifiers: CCE-27054-6

References: AC-6(7), 225, 1.5.2

Remediation Shell script: (show)

Complexity: | low
Disruption: | low
Reboot: | false
Strategy: | disable

    chmod 600 /boot/grub2/grub.cfg

#### Set Boot Loader Password [ref]rule

The grub2 boot loader should have a superuser account and password protection enabled to protect boot-time settings.
To do so, select a superuser account and password and add them into the `/etc/grub.d/01_users` configuration file.
Since plaintext passwords are a security risk, generate a hash for the pasword by running the following command:

    $ grub2-mkpasswd-pbkdf2

When prompted, enter the password that was selected and insert the returned password hash into the `/etc/grub.d/01_users` configuration file immediately after the superuser account. (Use the output from `grub2-mkpasswd-pbkdf2` as the value of password-hash):

    password_pbkdf2 superusers-account password-hash

NOTE: It is recommended not to use common administrator account names like root, admin, or administrator for the grub2 superuser account.
To meet FISMA Moderate, the bootloader superuser account and password MUST differ from the root account and password. Once the superuser account and password have been added, update the `grub.cfg` file by running:

    grub2-mkconfig -o /boot/grub2/grub.cfg

NOTE: Do NOT manually add the superuser account and password to the `grub.cfg` file as the grub2-mkconfig command overwrites this file. Rationale:

Password protection on the boot loader configuration ensures users with physical access cannot trivially alter important bootloader settings. These include which kernel to use, and whether to enter single-user mode. For more information on how to configure the grub2 superuser account and password, please refer to

- https://docs.redhat.com/docs/en-US/Red_Hat_Enterprise_Linux/7/html/System_Administrators_Guide/sec-GRUB_2_Password_Protection.html
.

Severity: high

Identifiers: CCE-27309-4

References: IA-2(1), IA-5(e), AC-3, 213, SRG-OS-000080-GPOS-00048, RHEL-07-010460, 1.5.3

#### Require Authentication for Single User Mode [ref]rule

Single-user mode is intended as a system recovery method, providing a single user root access to the system by providing a boot option at startup. By default, no authentication is performed if single-user mode is selected.
By default, single-user mode is protected by requiring a password and is set in `/usr/lib/systemd/system/rescue.service`.

Rationale:

This prevents attackers with physical access from trivially bypassing security on the machine and gaining root access. Such accesses are further prevented by configuring the bootloader password.

Severity: medium

Identifiers: CCE-27287-2

References: IA-2(1), AC-3, 213

Remediation Shell script: (show)

Complexity: | low
Disruption: | low
Reboot: | false
Strategy: | disable

    grep -q sulogin /usr/lib/systemd/system/rescue.service
    if ! [ $? -eq 0 ]; then
        sed -i "s/-c \"/-c \"\/sbin\/sulogin; /g" /usr/lib/systemd/system/rescue.service
    fi

### 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.

contains 4 rules

### firewalld [ref]group

The dynamic firewall daemon `firewalld` provides a dynamically managed firewall with support for network “zones” to assign a level of trust to a network and its associated connections and interfaces. It has support for IPv4 and IPv6 firewall settings. It supports Ethernet bridges and has a separation of runtime and permanent configuration options. It also has an interface for services or applications to add firewall rules directly.
A graphical configuration tool, `firewall-config`, is used to configure `firewalld`, which in turn uses `iptables` tool to communicate with `Netfilter` in the kernel which implements packet filtering.
The firewall service provided by `firewalld` is dynamic rather than static because changes to the configuration can be made at anytime and are immediately implemented. There is no need to save or apply the changes. No unintended disruption of existing network connections occurs as no part of the firewall has to be reloaded.

contains 2 rules

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

Firewalls can be used to separate networks into different zones based on the level of trust the user has decided to place on the devices and traffic within that network. `NetworkManager` informs firewalld to which zone an interface belongs. An interface's assigned zone can be changed by `NetworkManager` or via the `firewall-config` tool.
The zone settings in `/etc/firewalld/` are a range of preset settings which can be quickly applied to a network interface. These are the zones provided by firewalld sorted according to the default trust level of the zones from untrusted to trusted:

- `drop`

  Any incoming network packets are dropped, there is no reply. Only outgoing network connections are possible.

- `block`

  Any incoming network connections are rejected with an `icmp-host-prohibited` message for IPv4 and `icmp6-adm-prohibited` for IPv6. Only network connections initiated from within the system are possible.

- `public`

  For use in public areas. You do not trust the other computers on the network to not harm your computer. Only selected incoming connections are accepted.

- `external`

  For use on external networks with masquerading enabled especially for routers. You do not trust the other computers on the network to not harm your computer. Only selected incoming connections are accepted.

- `dmz`

  For computers in your demilitarized zone that are publicly-accessible with limited access to your internal network. Only selected incoming connections are accepted.

- `work`

  For use in work areas. You mostly trust the other computers on networks to not harm your computer. Only selected incoming connections are accepted.

- `home`

  For use in home areas. You mostly trust the other computers on networks to not harm your computer. Only selected incoming connections are accepted.

- `internal`

  For use on internal networks. You mostly trust the other computers on the networks to not harm your computer. Only selected incoming connections are accepted.

- `trusted`

  All network connections are accepted.

It is possible to designate one of these zones to be the default zone. When interface connections are added to `NetworkManager`, they are assigned to the default zone. On installation, the default zone in firewalld is set to be the public zone.
To find out all the settings of a zone, for example the `public zone,` enter the following command as root:

    # firewall-cmd --zone=public --list-all

Example output of this command might look like the following:

    # firewall-cmd --zone=public --list-all
    public
      interfaces:
      services: mdns dhcpv6-client ssh
      ports:
      forward-ports:
      icmp-blocks: source-quench

To view the network zones currently active, enter the following command as root:

    # firewall-cmd --get-service

The following listing displays the result of this command on common Red Hat Enterprise Linux 7 Server system:

    # firewall-cmd --get-service
    amanda-client bacula bacula-client dhcp dhcpv6 dhcpv6-client dns ftp
    high-availability http https imaps ipp ipp-client ipsec kerberos kpasswd
    ldap ldaps libvirt libvirt-tls mdns mountd ms-wbt mysql nfs ntp openvpn
    pmcd pmproxy pmwebapi pmwebapis pop3s postgresql proxy-dhcp radius rpc-bind
    samba samba-client smtp ssh telnet tftp tftp-client transmission-client
    vnc-server wbem-https

Finally to view the network zones that will be active after the next firewalld service reload, enter the following command as root:

    # firewall-cmd --get-service --permanent

contains 1 rule

#### Verify firewalld Enabled [ref]rule

The `firewalld` service can be enabled with the following command:

    $ sudo systemctl enable firewalld.service

Rationale:

Access control methods provide the ability to enhance system security posture by restricting services and known good IP addresses and address ranges. This prevents connections from unknown hosts and protocols.

Severity: medium

Identifiers: CCE-27361-5

References: CM-6(b), 366, 4.7, SRG-OS-000480-GPOS-00227, RHEL-07-040810

Remediation Shell script: (show)

Complexity: | low
Disruption: | low
Reboot: | false
Strategy: | enable

    function service_command {

    # Load function arguments into local variables
    local service_state=$1
    local service=$2
    local xinetd=$(echo $3 | cut -d'=' -f2)

    # Check sanity of the input
    if [ $# -lt "2" ]
    then
      echo "Usage: service_command 'enable/disable' 'service_name.service'"
      echo
      echo "To enable or disable xinetd services add \'xinetd=service_name\'"
      echo "as the last argument"
      echo "Aborting."
      exit 1
    fi

    # If systemctl is installed, use systemctl command; otherwise, use the service/chkconfig commands
    if [ -f "/usr/bin/systemctl" ] ; then
      service_util="/usr/bin/systemctl"
    else
      service_util="/sbin/service"
      chkconfig_util="/sbin/chkconfig"
    fi

    # If disable is not specified in arg1, set variables to enable services.
    # Otherwise, variables are to be set to disable services.
    if [ "$service_state" != 'disable' ] ; then
      service_state="enable"
      service_operation="start"
      chkconfig_state="on"
    else
      service_state="disable"
      service_operation="stop"
      chkconfig_state="off"
    fi

    # If chkconfig_util is not empty, use chkconfig/service commands.
    if ! [ "x$chkconfig_util" = x ] ; then
      $service_util $service $service_operation
      $chkconfig_util --level 0123456 $service $chkconfig_state
    else
      $service_util $service_operation $service
      $service_util $service_state $service
    fi

    # Test if local variable xinetd is empty using non-bashism.
    # If empty, then xinetd is not being used.
    if ! [ "x$xinetd" = x ] ; then
      grep -qi disable /etc/xinetd.d/$xinetd && \

      if ! [ "$service_operation" != 'disable' ] ; then
        sed -i "s/disable.*/disable         = no/gI" /etc/xinetd.d/$xinetd
      else
        sed -i "s/disable.*/disable         = yes/gI" /etc/xinetd.d/$xinetd
      fi
    fi

    }

    service_command enable firewalld

Remediation Ansible snippet: (show)

Complexity: | low
Disruption: | low
Reboot: | false
Strategy: | enable

    - name: Enable service firewalld
      service:
        name="{{item}}"
        enabled="yes"
        state="started"
      with_items:
        - firewalld

### 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 configuration files under the `/etc/firewalld/services` and `/etc/firewalld/zones` directories.
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 `firewall-cmd` program to load in rules under the `/etc/firewalld/services` and `/etc/firewalld/zones` directories.
Instructions apply to both unless otherwise noted. Language and address conventions for regular firewalld rules are used throughout this section.

Warning: The program `firewall-config` allows additional services to penetrate the default firewall rules and automatically adjusts the `firewalld` ruleset(s).

contains 1 rule

#### Set Default firewalld Zone for Incoming Packets [ref]rule

To set the default zone to `drop` for the built-in default zone which processes incoming IPv4 and IPv6 packets, modify the following line in `/etc/firewalld/firewalld.conf` to be:

    DefaultZone=drop

Rationale:

In `firewalld` the default zone is applied only after all the applicable rules in the table are examined for a match. Setting the default zone to `drop` implements proper design for a firewall, i.e. any packets which are not explicitly permitted should not be accepted.

Severity: medium

Identifiers: CCE-27349-0

References: CM-6(b), CM-7, 366, SRG-OS-000480-GPOS-00227, RHEL-07-040820

Remediation Shell script: (show)

Complexity: | low
Disruption: | low
Reboot: | false
Strategy: | disable

    grep -q ^DefaultZone= /etc/firewalld/firewalld.conf && \
      sed -i "s/DefaultZone=.*/DefaultZone=drop/g" /etc/firewalld/firewalld.conf
    if ! [ $? -eq 0 ]; then
        echo "DefaultZone=drop" >> /etc/firewalld/firewalld.conf
    fi

### 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.

Warning: Although these protocols are not commonly used, avoid disruption in your network environment by ensuring they are not needed prior to disabling them.

contains 2 rules

#### Disable DCCP Support [ref]rule

The Datagram Congestion Control Protocol (DCCP) is a relatively new transport layer protocol, designed to support streaming media and telephony. To configure the system to prevent the `dccp` kernel module from being loaded, add the following line to a file in the directory `/etc/modprobe.d`:

    install dccp /bin/true

Rationale:

Disabling DCCP protects the system against exploitation of any flaws in its implementation.

Severity: medium

Identifiers: CCE-26828-4

References: CM-7, http://iase.disa.mil/stigs/cci/Pages/index.aspx, 4.6.1

Remediation Shell script: (show)

Complexity: | low
Disruption: | medium
Reboot: | true
Strategy: | disable

    echo "install dccp /bin/true" > /etc/modprobe.d/dccp.conf

Remediation Ansible snippet: (show)

Complexity: | low
Disruption: | medium
Reboot: | true
Strategy: | disable

    - name: Ensure kernel module 'dccp' is disabled
      lineinfile:
        create=yes
        dest="/etc/modprobe.d/{{item}}.conf"
        regexp="{{item}}"
        line="install {{item}} /bin/true"
      with_items:
        - dccp

#### Disable SCTP Support [ref]rule

The Stream Control Transmission Protocol (SCTP) is a transport layer protocol, designed to support the idea of message-oriented communication, with several streams of messages within one connection. To configure the system to prevent the `sctp` kernel module from being loaded, add the following line to a file in the directory `/etc/modprobe.d`:

    install sctp /bin/true

Rationale:

Disabling SCTP protects the system against exploitation of any flaws in its implementation.

Severity: medium

Identifiers: CCE-27106-4

References: CM-7, http://iase.disa.mil/stigs/cci/Pages/index.aspx, 4.6.2

Remediation Shell script: (show)

Complexity: | low
Disruption: | medium
Reboot: | true
Strategy: | disable

    echo "install sctp /bin/true" > /etc/modprobe.d/sctp.conf

Remediation Ansible snippet: (show)

Complexity: | low
Disruption: | medium
Reboot: | true
Strategy: | disable

    - name: Ensure kernel module 'sctp' is disabled
      lineinfile:
        create=yes
        dest="/etc/modprobe.d/{{item}}.conf"
        regexp="{{item}}"
        line="install {{item}} /bin/true"
      with_items:
        - sctp

### System Accounting with auditd [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.
NOTE: The Linux Audit daemon `auditd` can be configured to use the `augenrules` program to read audit rules files (`*.rules`) located in `/etc/audit/rules.d` location and compile them to create the resulting form of the `/etc/audit/audit.rules` configuration file during the daemon startup (default configuration). Alternatively, the `auditd` daemon can use the `auditctl` utility to read audit rules from the `/etc/audit/audit.rules` configuration file during daemon startup, and load them into the kernel. The expected behavior is configured via the appropriate `ExecStartPost` directive setting in the `/usr/lib/systemd/system/auditd.service` configuration file. To instruct the `auditd` daemon to use the `augenrules` program to read audit rules (default configuration), use the following setting:

    ExecStartPost=-/sbin/augenrules --load

in the `/usr/lib/systemd/system/auditd.service` configuration file. In order to instruct the `auditd` daemon to use the `auditctl` utility to read audit rules, use the following setting:

    ExecStartPost=-/sbin/auditctl -R /etc/audit/audit.rules

in the `/usr/lib/systemd/system/auditd.service` configuration file. Refer to `[Service]` section of the `/usr/lib/systemd/system/auditd.service` configuration file for further details.
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 `https://access.redhat.com/documentation/en-US/Red_Hat_Enterprise_Linux/7/html/SELinux_Users_and_Administrators_Guide/sect-Security-Enhanced_Linux-Troubleshooting-Fixing_Problems.html#sect-Security-Enhanced_Linux-Fixing_Problems-Raw_Audit_Messages` 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"`.

contains 1 rule

### Configure auditd 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

contains 1 rule

#### System Audit Logs Must Have Mode 0640 or Less Permissive [ref]rule

If `log_group` in `/etc/audit/auditd.conf` is set to a group other than the `root` group account, change the mode of the audit log files with the following command:

    $ sudo chmod 0640 audit_file

Otherwise, change the mode of the audit log files with the following command:

    $ sudo chmod 0600 audit_file

Rationale:

If users can write to audit logs, audit trails can be modified or destroyed.

Severity: medium

Identifiers: CCE-27205-4

References: AC-6, AU-1(b), AU-9, IR-5, http://iase.disa.mil/stigs/cci/Pages/index.aspx, Req-10.5

Remediation Shell script: (show)

Complexity: | low
Disruption: | low
Reboot: | false
Strategy: | disable

    if `grep -q ^log_group /etc/audit/auditd.conf` ; then
      GROUP=$(awk -F "=" '/log_group/ {print $2}' /etc/audit/auditd.conf | tr -d ' ')
      if ! [ "${GROUP}" == 'root' ] ; then
        chmod 0640 /var/log/audit/audit.log
        chmod 0440 /var/log/audit/audit.log.*
      else
        chmod 0600 /var/log/audit/audit.log
        chmod 0400 /var/log/audit/audit.log.*
      fi

      chmod 0640 /etc/audit/audit*
      chmod 0640 /etc/audit/rules.d/*
    else
      chmod 0600 /var/log/audit/audit.log
      chmod 0400 /var/log/audit/audit.log.*
      chmod 0640 /etc/audit/audit*
      chmod 0640 /etc/audit/rules.d/*
    fi

### 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 7 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 7 system and provides guidance about which ones can be safely disabled.
Red Hat Enterprise Linux 7 provides a convenient minimal install option that essentially installs the bare necessities for a functional system. When building Red Hat Enterprise Linux 7 systems, it is highly recommended to select the minimal packages and then build up the system from there.

contains 14 rules

### 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 7 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 `firewalld` to restrict access to the vulnerable service to only those remote hosts which have a known need to use it.

contains 3 rules

### 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.

contains 3 rules

#### Disable telnet Service [ref]rule

The `telnet` service configuration file `/etc/xinetd.d/telnet` is not created automatically. If it was created manually, check the `/etc/xinetd.d/telnet` file and ensure that `disable = no` is changed to read `disable = yes` as follows below:

    # description: The telnet server serves telnet sessions; it uses \\
    #       unencrypted username/password pairs for authentication.
    service telnet
    {
            flags           = REUSE
            socket_type     = stream

            wait            = no
            user            = root
            server          = /usr/sbin/in.telnetd
            log_on_failure  += USERID
            disable         = yes
    }

If the `/etc/xinetd.d/telnet` file does not exist, make sure that the activation of the `telnet` service on system boot is disabled via the following command: The `rexec` socket can be disabled with the following command:

    $ sudo systemctl disable rexec.socket

Rationale:

The telnet protocol uses unencrypted network communication, which means that data from the login session, including passwords and all other information transmitted during the session, can be stolen by eavesdroppers on the network. The telnet protocol is also subject to man-in-the-middle attacks.

Severity: high

Identifiers: CCE-27401-9

References: AC-17(8), CM-7, IA-5(1)(c), http://iase.disa.mil/stigs/cci/Pages/index.aspx

Remediation Shell script: (show)

Complexity: | low
Disruption: | low
Reboot: | false
Strategy: | disable

    grep -qi disable /etc/xinetd.d/telnet && \
      sed -i "s/disable.*/disable         = yes/gI" /etc/xinetd.d/telnet

    #
    # Disable telnet.socket for all systemd targets
    #
    systemctl disable telnet.socket

    #
    # Stop telnet.socket if currently running
    #
    systemctl stop telnet.socket

#### Uninstall telnet-server Package [ref]rule

The `telnet-server` package can be uninstalled with the following command:

    $ sudo yum erase telnet-server

Rationale:

It is detrimental for operating systems to provide, or install by default, functionality exceeding requirements or mission objectives. These unnecessary capabilities are often overlooked and therefore may remain unsecure. They increase the risk to the platform by providing additional attack vectors.
The telnet service provides an unencrypted remote access service which does not provide for the confidentiality and integrity of user passwords or the remote session. If a privileged user were to login using this service, the privileged user password could be compromised.
Removing the `telnet-server` package decreases the risk of the telnet service's accidental (or intentional) activation.

Severity: high

Identifiers: CCE-27165-0

References: AC-17(8), CM-7(a), 381, SRG-OS-000095-GPOS-00049, RHEL-07-021910, 2.1.1

Remediation Shell script: (show)

Complexity: | low
Disruption: | low
Reboot: | false
Strategy: | disable

    function package_command {

    # Load function arguments into local variables
    local package_operation=$1
    local package=$2

    # Check sanity of the input
    if [ $# -ne "2" ]
    then
      echo "Usage: package_command 'install/uninstall' 'rpm_package_name"
      echo "Aborting."
      exit 1
    fi

    # If dnf is installed, use dnf; otherwise, use yum
    if [ -f "/usr/bin/dnf" ] ; then
      install_util="/usr/bin/dnf"
    else
      install_util="/usr/bin/yum"
    fi

    if [ "$package_operation" != 'remove' ] ; then
      # If the rpm is not installed, install the rpm
      if ! /bin/rpm -q --quiet $package; then
        $install_util -y $package_operation $package
      fi
    else
      # If the rpm is installed, uninstall the rpm
      if /bin/rpm -q --quiet $package; then
        $install_util -y $package_operation $package
      fi
    fi

    }

    package_command remove telnet-server

Remediation Ansible snippet: (show)

Complexity: | low
Disruption: | low
Reboot: | false
Strategy: | disable

    - name: Ensure telnet-server is removed
      package:
        name="{{item}}"
        state=absent
      with_items:
        - telnet-server

Remediation Puppet snippet: (show)

Complexity: | low
Disruption: | low
Reboot: | false
Strategy: | disable

    include remove_telnet-server

    class remove_telnet-server {
      package { 'telnet-server':
        ensure => 'purged',
      }
    }

Remediation Anaconda snippet: (show)

Complexity: | low
Disruption: | low
Reboot: | false
Strategy: | disable

    package -remove=telnet-server

#### Remove telnet Clients [ref]rule

The telnet client allows users to start connections to other systems via the telnet protocol.

Rationale:

The `telnet` protocol is insecure and unencrypted. The use of an unencrypted transmission medium could allow an unauthorized user to steal credentials. The `ssh` package provides an encrypted session and stronger security and is included in Red Hat Enterprise Linux.

Severity: low

Identifiers: CCE-27305-2

References: 2.1.2

Remediation Shell script: (show)

Complexity: | low
Disruption: | low
Reboot: | false
Strategy: | disable

    function package_command {

    # Load function arguments into local variables
    local package_operation=$1
    local package=$2

    # Check sanity of the input
    if [ $# -ne "2" ]
    then
      echo "Usage: package_command 'install/uninstall' 'rpm_package_name"
      echo "Aborting."
      exit 1
    fi

    # If dnf is installed, use dnf; otherwise, use yum
    if [ -f "/usr/bin/dnf" ] ; then
      install_util="/usr/bin/dnf"
    else
      install_util="/usr/bin/yum"
    fi

    if [ "$package_operation" != 'remove' ] ; then
      # If the rpm is not installed, install the rpm
      if ! /bin/rpm -q --quiet $package; then
        $install_util -y $package_operation $package
      fi
    else
      # If the rpm is installed, uninstall the rpm
      if /bin/rpm -q --quiet $package; then
        $install_util -y $package_operation $package
      fi
    fi

    }

    package_command remove telnet

Remediation Ansible snippet: (show)

Complexity: | low
Disruption: | low
Reboot: | false
Strategy: | disable

    - name: Ensure telnet is removed
      package:
        name="{{item}}"
        state=absent
      with_items:
        - telnet

Remediation Puppet snippet: (show)

Complexity: | low
Disruption: | low
Reboot: | false
Strategy: | disable

    include remove_telnet

    class remove_telnet {
      package { 'telnet':
        ensure => 'purged',
      }
    }

Remediation Anaconda snippet: (show)

Complexity: | low
Disruption: | low
Reboot: | false
Strategy: | disable

    package -remove=telnet

### Base Services [ref]group

This section addresses the base services that are installed on a Red Hat Enterprise Linux 7 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.

contains 1 rule

#### Disable Automatic Bug Reporting Tool (abrtd) [ref]rule

The Automatic Bug Reporting Tool (`abrtd`) daemon collects and reports crash data when an application crash is detected. Using a variety of plugins, abrtd can email crash reports to system administrators, log crash reports to files, or forward crash reports to a centralized issue tracking system such as RHTSupport. The `abrtd` service can be disabled with the following command:

    $ sudo systemctl disable abrtd.service

Rationale:

Mishandling crash data could expose sensitive information about vulnerabilities in software executing on the local machine, as well as sensitive information from within a process's address space or registers.

Severity: low

Identifiers: CCE-26872-2

References: AC-17(8), CM-7, http://iase.disa.mil/stigs/cci/Pages/index.aspx

Remediation Shell script: (show)

Complexity: | low
Disruption: | low
Reboot: | false
Strategy: | disable

    function service_command {

    # Load function arguments into local variables
    local service_state=$1
    local service=$2
    local xinetd=$(echo $3 | cut -d'=' -f2)

    # Check sanity of the input
    if [ $# -lt "2" ]
    then
      echo "Usage: service_command 'enable/disable' 'service_name.service'"
      echo
      echo "To enable or disable xinetd services add \'xinetd=service_name\'"
      echo "as the last argument"
      echo "Aborting."
      exit 1
    fi

    # If systemctl is installed, use systemctl command; otherwise, use the service/chkconfig commands
    if [ -f "/usr/bin/systemctl" ] ; then
      service_util="/usr/bin/systemctl"
    else
      service_util="/sbin/service"
      chkconfig_util="/sbin/chkconfig"
    fi

    # If disable is not specified in arg1, set variables to enable services.
    # Otherwise, variables are to be set to disable services.
    if [ "$service_state" != 'disable' ] ; then
      service_state="enable"
      service_operation="start"
      chkconfig_state="on"
    else
      service_state="disable"
      service_operation="stop"
      chkconfig_state="off"
    fi

    # If chkconfig_util is not empty, use chkconfig/service commands.
    if ! [ "x$chkconfig_util" = x ] ; then
      $service_util $service $service_operation
      $chkconfig_util --level 0123456 $service $chkconfig_state
    else
      $service_util $service_operation $service
      $service_util $service_state $service
    fi

    # Test if local variable xinetd is empty using non-bashism.
    # If empty, then xinetd is not being used.
    if ! [ "x$xinetd" = x ] ; then
      grep -qi disable /etc/xinetd.d/$xinetd && \

      if ! [ "$service_operation" != 'disable' ] ; then
        sed -i "s/disable.*/disable         = no/gI" /etc/xinetd.d/$xinetd
      else
        sed -i "s/disable.*/disable         = yes/gI" /etc/xinetd.d/$xinetd
      fi
    fi

    }

    service_command disable abrtd

Remediation Ansible snippet: (show)

Complexity: | low
Disruption: | low
Reboot: | false
Strategy: | disable

    - name: Disable service abrtd
      service:
        name="{{item}}"
        enabled="no"
        state="stopped"
      with_items:
        - abrtd

### 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`.

contains 10 rules

### 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.

contains 10 rules

#### Allow Only SSH Protocol 2 [ref]rule

Only SSH protocol version 2 connections should be permitted. The default setting in `/etc/ssh/sshd_config` is correct, and can be verified by ensuring that the following line appears:

    Protocol 2

Rationale:

SSH protocol version 1 is an insecure implementation of the SSH protocol and has many well-known vulnerability exploits. Exploits of the SSH daemon could provide immediate root access to the system.

Severity: high

Identifiers: CCE-27320-1

References: AC-17(8).1(ii), IA-5(1)(c), 197, 366, 6.2.1, SRG-OS-000074-GPOS-00042, SRG-OS-000480-GPOS-00227, RHEL-07-040590

Remediation Shell script: (show)

Complexity: | low
Disruption: | low
Reboot: | false
Strategy: | disable

    function replace_or_append {
      local config_file=$1
      local key=$2
      local value=$3
      local cce=$4
      local format=$5

      # Check sanity of the input
      if [ $# -lt "3" ]
      then
            echo "Usage: replace_or_append 'config_file_location' 'key_to_search' 'new_value'"
            echo
            echo "If symlinks need to be taken into account, add yes/no to the last argument"
            echo "to allow to 'follow_symlinks'."
            echo "Aborting."
            exit 1
      fi

      # Test if the config_file is a symbolic link. If so, use --follow-symlinks with sed.
      # Otherwise, regular sed command will do.
      if test -L $config_file; then
        sed_command="sed -i --follow-symlinks"
      else
        sed_command="sed -i"
      fi

      # Test that the cce arg is not empty or does not equal $CCENUM.
      # If $CCENUM exists, it means that there is no CCE assigned.
      if ! [ "x$cce" = x ] && [ "$cce" != '$CCENUM' ]; then
        cce="CCE-${cce}"
      else
        cce="CCE"
      fi

      # Strip any search characters in the key arg so that the key can be replaced without
      # adding any search characters to the config file.
      stripped_key=$(sed "s/[\^=\$,;+]*//g" <<< $key)

      # If there is no print format specified in the last arg, use the default format.
      if ! [ "x$format" = x ] ; then
        printf -v formatted_output "$format" $stripped_key $value
      else
        formatted_output="$stripped_key = $value"
      fi

      # If the key exists, change it. Otherwise, add it to the config_file.
      if `grep -qi $key $config_file` ; then
        $sed_command "s/$key.*/$formatted_output/g" $config_file
      else
        echo -ne "\n# Per $cce: Set $formatted_output in $config_file" >> $config_file
        echo -ne "\n$formatted_output" >> $config_file
      fi

    }

    replace_or_append '/etc/ssh/sshd_config' '^Protocol' '2' 'CCE-27320-1' '%s %s'

#### Set SSH Idle Timeout Interval [ref]rule

SSH allows administrators to set an idle timeout interval. After this interval has passed, the idle user will be automatically logged out.
To set an idle timeout interval, edit the following line in `/etc/ssh/sshd_config` as follows:

    ClientAliveInterval interval

The timeout interval is given in seconds. To have a timeout of 10 minutes, set interval to 600.
If a shorter timeout has already been set for the login shell, that value will preempt any SSH setting made here. Keep in mind that some processes may stop SSH from correctly detecting that the user is idle. Rationale:

Terminating an idle ssh session within a short time period reduces the window of opportunity for unauthorized personnel to take control of a management session enabled on the console or console port that has been let unattended.

Severity: low

Identifiers: CCE-27433-2

References: AC-2(5), SA-8(i), AC-12, 1133, 2361, SRG-OS-000163-GPOS-00072, SRG-OS-000279-GPOS-00109, RHEL-07-040190, Req-8.1.8, 6.2.12

Remediation Shell script: (show)

Complexity: | low
Disruption: | low
Reboot: | false
Strategy: | disable

    sshd_idle_timeout_value="300"

    function replace_or_append {
      local config_file=$1
      local key=$2
      local value=$3
      local cce=$4
      local format=$5

      # Check sanity of the input
      if [ $# -lt "3" ]
      then
            echo "Usage: replace_or_append 'config_file_location' 'key_to_search' 'new_value'"
            echo
            echo "If symlinks need to be taken into account, add yes/no to the last argument"
            echo "to allow to 'follow_symlinks'."
            echo "Aborting."
            exit 1
      fi

      # Test if the config_file is a symbolic link. If so, use --follow-symlinks with sed.
      # Otherwise, regular sed command will do.
      if test -L $config_file; then
        sed_command="sed -i --follow-symlinks"
      else
        sed_command="sed -i"
      fi

      # Test that the cce arg is not empty or does not equal $CCENUM.
      # If $CCENUM exists, it means that there is no CCE assigned.
      if ! [ "x$cce" = x ] && [ "$cce" != '$CCENUM' ]; then
        cce="CCE-${cce}"
      else
        cce="CCE"
      fi

      # Strip any search characters in the key arg so that the key can be replaced without
      # adding any search characters to the config file.
      stripped_key=$(sed "s/[\^=\$,;+]*//g" <<< $key)

      # If there is no print format specified in the last arg, use the default format.
      if ! [ "x$format" = x ] ; then
        printf -v formatted_output "$format" $stripped_key $value
      else
        formatted_output="$stripped_key = $value"
      fi

      # If the key exists, change it. Otherwise, add it to the config_file.
      if `grep -qi $key $config_file` ; then
        $sed_command "s/$key.*/$formatted_output/g" $config_file
      else
        echo -ne "\n# Per $cce: Set $formatted_output in $config_file" >> $config_file
        echo -ne "\n$formatted_output" >> $config_file
      fi

    }

    replace_or_append '/etc/ssh/sshd_config' '^ClientAliveInterval' $sshd_idle_timeout_value 'CCE-27433-2' '%s %s'

Remediation Ansible snippet: (show)

Complexity: | low
Disruption: | low
Reboot: | false
Strategy: | disable

    - name: "SSHD: Set client alive interval"
      lineinfile:
        create=yes
        dest="/etc/ssh/sshd_config"
        regexp="^ClientAliveInterval"
        line="ClientAliveInterval 300"

#### Set SSH Client Alive Count [ref]rule

To ensure the SSH idle timeout occurs precisely when the `ClientAliveCountMax` is set, edit `/etc/ssh/sshd_config` as follows:

    ClientAliveCountMax 0

Rationale:

This ensures a user login will be terminated as soon as the `ClientAliveCountMax` is reached.

Severity: medium

Identifiers: CCE-27082-7

References: AC-2(5), SA-8, AC-12, 1133, 2361, SRG-OS-000163-GPOS-00072, SRG-OS-000279-GPOS-00109, RHEL-07-040191, 6.2.12

Remediation Shell script: (show)

Complexity: | low
Disruption: | low
Reboot: | false
Strategy: | disable

    function replace_or_append {
      local config_file=$1
      local key=$2
      local value=$3
      local cce=$4
      local format=$5

      # Check sanity of the input
      if [ $# -lt "3" ]
      then
            echo "Usage: replace_or_append 'config_file_location' 'key_to_search' 'new_value'"
            echo
            echo "If symlinks need to be taken into account, add yes/no to the last argument"
            echo "to allow to 'follow_symlinks'."
            echo "Aborting."
            exit 1
      fi

      # Test if the config_file is a symbolic link. If so, use --follow-symlinks with sed.
      # Otherwise, regular sed command will do.
      if test -L $config_file; then
        sed_command="sed -i --follow-symlinks"
      else
        sed_command="sed -i"
      fi

      # Test that the cce arg is not empty or does not equal $CCENUM.
      # If $CCENUM exists, it means that there is no CCE assigned.
      if ! [ "x$cce" = x ] && [ "$cce" != '$CCENUM' ]; then
        cce="CCE-${cce}"
      else
        cce="CCE"
      fi

      # Strip any search characters in the key arg so that the key can be replaced without
      # adding any search characters to the config file.
      stripped_key=$(sed "s/[\^=\$,;+]*//g" <<< $key)

      # If there is no print format specified in the last arg, use the default format.
      if ! [ "x$format" = x ] ; then
        printf -v formatted_output "$format" $stripped_key $value
      else
        formatted_output="$stripped_key = $value"
      fi

      # If the key exists, change it. Otherwise, add it to the config_file.
      if `grep -qi $key $config_file` ; then
        $sed_command "s/$key.*/$formatted_output/g" $config_file
      else
        echo -ne "\n# Per $cce: Set $formatted_output in $config_file" >> $config_file
        echo -ne "\n$formatted_output" >> $config_file
      fi

    }

    replace_or_append '/etc/ssh/sshd_config' '^ClientAliveCountMax' '0' 'CCE-27082-7' '%s %s'

#### Disable SSH Support for .rhosts Files [ref]rule

SSH can emulate the behavior of the obsolete rsh command in allowing users to enable insecure access to their accounts via `.rhosts` files.
To ensure this behavior is disabled, add or correct the following line in `/etc/ssh/sshd_config`:

    IgnoreRhosts yes

Rationale:

SSH trust relationships mean a compromise on one host can allow an attacker to move trivially to other hosts.

Severity: medium

Identifiers: CCE-27377-1

References: AC-3, CM-6(a), 366, 6.2.6, RHEL-07-040334, SRG-OS-000480-GPOS-00227

Remediation Shell script: (show)

Complexity: | low
Disruption: | low
Reboot: | false
Strategy: | disable

    function replace_or_append {
      local config_file=$1
      local key=$2
      local value=$3
      local cce=$4
      local format=$5

      # Check sanity of the input
      if [ $# -lt "3" ]
      then
            echo "Usage: replace_or_append 'config_file_location' 'key_to_search' 'new_value'"
            echo
            echo "If symlinks need to be taken into account, add yes/no to the last argument"
            echo "to allow to 'follow_symlinks'."
            echo "Aborting."
            exit 1
      fi

      # Test if the config_file is a symbolic link. If so, use --follow-symlinks with sed.
      # Otherwise, regular sed command will do.
      if test -L $config_file; then
        sed_command="sed -i --follow-symlinks"
      else
        sed_command="sed -i"
      fi

      # Test that the cce arg is not empty or does not equal $CCENUM.
      # If $CCENUM exists, it means that there is no CCE assigned.
      if ! [ "x$cce" = x ] && [ "$cce" != '$CCENUM' ]; then
        cce="CCE-${cce}"
      else
        cce="CCE"
      fi

      # Strip any search characters in the key arg so that the key can be replaced without
      # adding any search characters to the config file.
      stripped_key=$(sed "s/[\^=\$,;+]*//g" <<< $key)

      # If there is no print format specified in the last arg, use the default format.
      if ! [ "x$format" = x ] ; then
        printf -v formatted_output "$format" $stripped_key $value
      else
        formatted_output="$stripped_key = $value"
      fi

      # If the key exists, change it. Otherwise, add it to the config_file.
      if `grep -qi $key $config_file` ; then
        $sed_command "s/$key.*/$formatted_output/g" $config_file
      else
        echo -ne "\n# Per $cce: Set $formatted_output in $config_file" >> $config_file
        echo -ne "\n$formatted_output" >> $config_file
      fi

    }

    replace_or_append '/etc/ssh/sshd_config' '^IgnoreRhosts' 'yes' 'CCE-27377-1' '%s %s'

#### Disable Host-Based Authentication [ref]rule

SSH's cryptographic host-based authentication is more secure than `.rhosts` authentication. However, it is not recommended that hosts unilaterally trust one another, even within an organization.
To disable host-based authentication, add or correct the following line in `/etc/ssh/sshd_config`:

    HostbasedAuthentication no

Rationale:

SSH trust relationships mean a compromise on one host can allow an attacker to move trivially to other hosts.

Severity: medium

Identifiers: CCE-27413-4

References: AC-3, CM-6(b), 366, SRG-OS-000480-GPOS-00229, RHEL-07-010442, 6.2.7

Remediation Shell script: (show)

Complexity: | low
Disruption: | low
Reboot: | false
Strategy: | disable

    grep -q ^HostbasedAuthentication /etc/ssh/sshd_config && \
      sed -i "s/HostbasedAuthentication.*/HostbasedAuthentication no/g" /etc/ssh/sshd_config
    if ! [ $? -eq 0 ]; then
        echo "HostbasedAuthentication no" >> /etc/ssh/sshd_config
    fi

#### Disable SSH Root Login [ref]rule

The root user should never be allowed to login to a system directly over a network. To disable root login via SSH, add or correct the following line in `/etc/ssh/sshd_config`:

    PermitRootLogin no

Rationale:

Even though the communications channel may be encrypted, an additional layer of security is gained by extending the policy of not logging directly on as root. In addition, logging in with a user-specific account provides individual accountability of actions performed on the system and also helps to minimize direct attack attempts on root's password.

Severity: medium

Identifiers: CCE-27445-6

References: AC-3, AC-6(2), IA-2(1), IA-2(5), 366, SRG-OS-000480-GPOS-00227, RHEL-07-040310, 6.2.8

Remediation Shell script: (show)

Complexity: | low
Disruption: | low
Reboot: | false
Strategy: | disable

    SSHD_CONFIG='/etc/ssh/sshd_config'

    # Obtain line number of first uncommented case-insensitive occurrence of Match
    # block directive (possibly prefixed with whitespace) present in $SSHD_CONFIG
    FIRST_MATCH_BLOCK=$(sed -n '/^[[:space:]]*Match[^\n]*/I{=;q}' $SSHD_CONFIG)

    # Obtain line number of first uncommented case-insensitive occurence of
    # PermitRootLogin directive (possibly prefixed with whitespace) present in
    # $SSHD_CONFIG
    FIRST_PERMIT_ROOT_LOGIN=$(sed -n '/^[[:space:]]*PermitRootLogin[^\n]*/I{=;q}' $SSHD_CONFIG)

    # Case: Match block directive not present in $SSHD_CONFIG
    if [ -z "$FIRST_MATCH_BLOCK" ]
    then

        # Case: PermitRootLogin directive not present in $SSHD_CONFIG yet
        if [ -z "$FIRST_PERMIT_ROOT_LOGIN" ]
        then
            # Append 'PermitRootLogin no' at the end of $SSHD_CONFIG
            echo -e "\nPermitRootLogin no" >> $SSHD_CONFIG

        # Case: PermitRootLogin directive present in $SSHD_CONFIG already
        else
            # Replace first uncommented case-insensitive occurrence
            # of PermitRootLogin directive
            sed -i "$FIRST_PERMIT_ROOT_LOGIN s/^[[:space:]]*PermitRootLogin.*$/PermitRootLogin no/I" $SSHD_CONFIG
        fi

    # Case: Match block directive present in $SSHD_CONFIG
    else

        # Case: PermitRootLogin directive not present in $SSHD_CONFIG yet
        if [ -z "$FIRST_PERMIT_ROOT_LOGIN" ]
        then
            # Prepend 'PermitRootLogin no' before first uncommented
            # case-insensitive occurrence of Match block directive
            sed -i "$FIRST_MATCH_BLOCK s/^\([[:space:]]*Match[^\n]*\)/PermitRootLogin no\n\1/I" $SSHD_CONFIG

        # Case: PermitRootLogin directive present in $SSHD_CONFIG and placed
        #       before first Match block directive
        elif [ "$FIRST_PERMIT_ROOT_LOGIN" -lt "$FIRST_MATCH_BLOCK" ]
        then
            # Replace first uncommented case-insensitive occurrence
            # of PermitRootLogin directive
            sed -i "$FIRST_PERMIT_ROOT_LOGIN s/^[[:space:]]*PermitRootLogin.*$/PermitRootLogin no/I" $SSHD_CONFIG

        # Case: PermitRootLogin directive present in $SSHD_CONFIG and placed
        # after first Match block directive
        else
             # Prepend 'PermitRootLogin no' before first uncommented
             # case-insensitive occurrence of Match block directive
             sed -i "$FIRST_MATCH_BLOCK s/^\([[:space:]]*Match[^\n]*\)/PermitRootLogin no\n\1/I" $SSHD_CONFIG
        fi
    fi

#### Disable SSH Access via Empty Passwords [ref]rule

To explicitly disallow SSH login from accounts with empty passwords, add or correct the following line in `/etc/ssh/sshd_config`:

    PermitEmptyPasswords no

Any accounts with empty passwords should be disabled immediately, and PAM configuration should prevent users from being able to assign themselves empty passwords. Rationale:

Configuring this setting for the SSH daemon provides additional assurance that remote login via SSH will require a password, even in the event of misconfiguration elsewhere.

Severity: high

Identifiers: CCE-27471-2

References: AC-3, AC-6, CM-6(b), 366, SRG-OS-000480-GPOS-00229, RHEL-07-010270

Remediation Shell script: (show)

Complexity: | low
Disruption: | low
Reboot: | false
Strategy: | disable

    function replace_or_append {
      local config_file=$1
      local key=$2
      local value=$3
      local cce=$4
      local format=$5

      # Check sanity of the input
      if [ $# -lt "3" ]
      then
            echo "Usage: replace_or_append 'config_file_location' 'key_to_search' 'new_value'"
            echo
            echo "If symlinks need to be taken into account, add yes/no to the last argument"
            echo "to allow to 'follow_symlinks'."
            echo "Aborting."
            exit 1
      fi

      # Test if the config_file is a symbolic link. If so, use --follow-symlinks with sed.
      # Otherwise, regular sed command will do.
      if test -L $config_file; then
        sed_command="sed -i --follow-symlinks"
      else
        sed_command="sed -i"
      fi

      # Test that the cce arg is not empty or does not equal $CCENUM.
      # If $CCENUM exists, it means that there is no CCE assigned.
      if ! [ "x$cce" = x ] && [ "$cce" != '$CCENUM' ]; then
        cce="CCE-${cce}"
      else
        cce="CCE"
      fi

      # Strip any search characters in the key arg so that the key can be replaced without
      # adding any search characters to the config file.
      stripped_key=$(sed "s/[\^=\$,;+]*//g" <<< $key)

      # If there is no print format specified in the last arg, use the default format.
      if ! [ "x$format" = x ] ; then
        printf -v formatted_output "$format" $stripped_key $value
      else
        formatted_output="$stripped_key = $value"
      fi

      # If the key exists, change it. Otherwise, add it to the config_file.
      if `grep -qi $key $config_file` ; then
        $sed_command "s/$key.*/$formatted_output/g" $config_file
      else
        echo -ne "\n# Per $cce: Set $formatted_output in $config_file" >> $config_file
        echo -ne "\n$formatted_output" >> $config_file
      fi

    }

    replace_or_append '/etc/ssh/sshd_config' '^PermitEmptyPasswords' 'no' 'CCE-27471-2' '%s %s'

Remediation Ansible snippet: (show)

Complexity: | low
Disruption: | low
Reboot: | false
Strategy: | disable

    - name: "SSHD: Disable empty passwords"
      lineinfile:
        create=yes
        dest="/etc/ssh/sshd_config"
        regexp="^PermitEmptyPasswords"
        line="PermitEmptyPasswords no"

#### Enable SSH Warning Banner [ref]rule

To enable the warning banner and ensure it is consistent across the system, add or correct the following line in `/etc/ssh/sshd_config`:

    Banner /etc/issue

Another section contains information on how to create an appropriate system-wide warning banner. Rationale:

The warning message reinforces policy awareness during the logon process and facilitates possible legal action against attackers. Alternatively, systems whose ownership should not be obvious should ensure usage of a banner that does not provide easy attribution.

Severity: medium

Identifiers: CCE-27314-4

References: AC-8(a), AC-8(b), AC-8(c)(1), AC-8(c)(2), AC-8(c)(3), 48, 50, 1384, 1385, 1386, 1387, 1388, SRG-OS-000023-GPOS-00006, SRG-OS-000024-GPOS-00007, SRG-OS-000228-GPOS-00088, 6.2.14, RHEL-07-040170

Remediation Shell script: (show)

Complexity: | low
Disruption: | low
Reboot: | false
Strategy: | disable

    function replace_or_append {
      local config_file=$1
      local key=$2
      local value=$3
      local cce=$4
      local format=$5

      # Check sanity of the input
      if [ $# -lt "3" ]
      then
            echo "Usage: replace_or_append 'config_file_location' 'key_to_search' 'new_value'"
            echo
            echo "If symlinks need to be taken into account, add yes/no to the last argument"
            echo "to allow to 'follow_symlinks'."
            echo "Aborting."
            exit 1
      fi

      # Test if the config_file is a symbolic link. If so, use --follow-symlinks with sed.
      # Otherwise, regular sed command will do.
      if test -L $config_file; then
        sed_command="sed -i --follow-symlinks"
      else
        sed_command="sed -i"
      fi

      # Test that the cce arg is not empty or does not equal $CCENUM.
      # If $CCENUM exists, it means that there is no CCE assigned.
      if ! [ "x$cce" = x ] && [ "$cce" != '$CCENUM' ]; then
        cce="CCE-${cce}"
      else
        cce="CCE"
      fi

      # Strip any search characters in the key arg so that the key can be replaced without
      # adding any search characters to the config file.
      stripped_key=$(sed "s/[\^=\$,;+]*//g" <<< $key)

      # If there is no print format specified in the last arg, use the default format.
      if ! [ "x$format" = x ] ; then
        printf -v formatted_output "$format" $stripped_key $value
      else
        formatted_output="$stripped_key = $value"
      fi

      # If the key exists, change it. Otherwise, add it to the config_file.
      if `grep -qi $key $config_file` ; then
        $sed_command "s/$key.*/$formatted_output/g" $config_file
      else
        echo -ne "\n# Per $cce: Set $formatted_output in $config_file" >> $config_file
        echo -ne "\n$formatted_output" >> $config_file
      fi

    }

    replace_or_append '/etc/ssh/sshd_config' '^Banner' '/etc/issue' 'CCE-27314-4' '%s %s'

Remediation Ansible snippet: (show)

Complexity: | low
Disruption: | low
Reboot: | false
Strategy: | disable

    - name: "SSHD: Enable warning banner"
      lineinfile:
        create=yes
        dest="/etc/ssh/sshd_config"
        regexp="^Banner"
        line="Banner /etc/issue"

#### Do Not Allow SSH Environment Options [ref]rule

To ensure users are not able to override environment options to the SSH daemon, add or correct the following line in `/etc/ssh/sshd_config`:

    PermitUserEnvironment no

Rationale:

SSH environment options potentially allow users to bypass access restriction in some configurations.

Severity: medium

Identifiers: CCE-27363-1

References: CM-6(b), 366, SRG-OS-000480-GPOS-00229, RHEL-07-010441, 6.2.10

Remediation Shell script: (show)

Complexity: | low
Disruption: | low
Reboot: | false
Strategy: | disable

    function replace_or_append {
      local config_file=$1
      local key=$2
      local value=$3
      local cce=$4
      local format=$5

      # Check sanity of the input
      if [ $# -lt "3" ]
      then
            echo "Usage: replace_or_append 'config_file_location' 'key_to_search' 'new_value'"
            echo
            echo "If symlinks need to be taken into account, add yes/no to the last argument"
            echo "to allow to 'follow_symlinks'."
            echo "Aborting."
            exit 1
      fi

      # Test if the config_file is a symbolic link. If so, use --follow-symlinks with sed.
      # Otherwise, regular sed command will do.
      if test -L $config_file; then
        sed_command="sed -i --follow-symlinks"
      else
        sed_command="sed -i"
      fi

      # Test that the cce arg is not empty or does not equal $CCENUM.
      # If $CCENUM exists, it means that there is no CCE assigned.
      if ! [ "x$cce" = x ] && [ "$cce" != '$CCENUM' ]; then
        cce="CCE-${cce}"
      else
        cce="CCE"
      fi

      # Strip any search characters in the key arg so that the key can be replaced without
      # adding any search characters to the config file.
      stripped_key=$(sed "s/[\^=\$,;+]*//g" <<< $key)

      # If there is no print format specified in the last arg, use the default format.
      if ! [ "x$format" = x ] ; then
        printf -v formatted_output "$format" $stripped_key $value
      else
        formatted_output="$stripped_key = $value"
      fi

      # If the key exists, change it. Otherwise, add it to the config_file.
      if `grep -qi $key $config_file` ; then
        $sed_command "s/$key.*/$formatted_output/g" $config_file
      else
        echo -ne "\n# Per $cce: Set $formatted_output in $config_file" >> $config_file
        echo -ne "\n$formatted_output" >> $config_file
      fi

    }

    replace_or_append '/etc/ssh/sshd_config' '^PermitUserEnvironment' 'no' 'CCE-27363-1' '%s %s'

Remediation Ansible snippet: (show)

Complexity: | low
Disruption: | low
Reboot: | false
Strategy: | disable

    - name: "SSHD: Do not permit user environment"
      lineinfile:
        create=yes
        dest="/etc/ssh/sshd_config"
        regexp="^PermitUserEnvironment"
        line="PermitUserEnvironment no"

#### Use Only Approved Ciphers [ref]rule

Limit the ciphers to those algorithms which are FIPS-approved. Counter (CTR) mode is also preferred over cipher-block chaining (CBC) mode. The following line in `/etc/ssh/sshd_config` demonstrates use of FIPS-approved ciphers:

    Ciphers aes128-ctr,aes192-ctr,aes256-ctr

The man page `sshd_config(5)` contains a list of supported ciphers. Rationale:

Unapproved mechanisms that are used for authentication to the cryptographic module are not verified and therefore cannot be relied upon to provide confidentiality or integrity, and system data may be compromised.
Operating systems utilizing encryption are required to use FIPS-compliant mechanisms for authenticating to cryptographic modules.
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.

Severity: medium

Identifiers: CCE-27295-5

References: AC-3, AC-17(2), AU-10(5), CM-6(b), IA-5(1)(c), IA-7, 68, 366, 803, SRG-OS-000033-GPOS-00014, SRG-OS-000120-GPOS-00061, SRG-OS-000125-GPOS-00065, SRG-OS-000250-GPOS-00093, SRG-OS-000393-GPOS-00173, RHEL-07-040110, 6.2.11

Remediation Shell script: (show)

Complexity: | low
Disruption: | low
Reboot: | false
Strategy: | disable

    function replace_or_append {
      local config_file=$1
      local key=$2
      local value=$3
      local cce=$4
      local format=$5

      # Check sanity of the input
      if [ $# -lt "3" ]
      then
            echo "Usage: replace_or_append 'config_file_location' 'key_to_search' 'new_value'"
            echo
            echo "If symlinks need to be taken into account, add yes/no to the last argument"
            echo "to allow to 'follow_symlinks'."
            echo "Aborting."
            exit 1
      fi

      # Test if the config_file is a symbolic link. If so, use --follow-symlinks with sed.
      # Otherwise, regular sed command will do.
      if test -L $config_file; then
        sed_command="sed -i --follow-symlinks"
      else
        sed_command="sed -i"
      fi

      # Test that the cce arg is not empty or does not equal $CCENUM.
      # If $CCENUM exists, it means that there is no CCE assigned.
      if ! [ "x$cce" = x ] && [ "$cce" != '$CCENUM' ]; then
        cce="CCE-${cce}"
      else
        cce="CCE"
      fi

      # Strip any search characters in the key arg so that the key can be replaced without
      # adding any search characters to the config file.
      stripped_key=$(sed "s/[\^=\$,;+]*//g" <<< $key)

      # If there is no print format specified in the last arg, use the default format.
      if ! [ "x$format" = x ] ; then
        printf -v formatted_output "$format" $stripped_key $value
      else
        formatted_output="$stripped_key = $value"
      fi

      # If the key exists, change it. Otherwise, add it to the config_file.
      if `grep -qi $key $config_file` ; then
        $sed_command "s/$key.*/$formatted_output/g" $config_file
      else
        echo -ne "\n# Per $cce: Set $formatted_output in $config_file" >> $config_file
        echo -ne "\n$formatted_output" >> $config_file
      fi

    }

    replace_or_append '/etc/ssh/sshd_config' '^Ciphers' 'aes128-ctr,aes192-ctr,aes256-ctr,aes128-cbc,3des-cbc,aes192-cbc,aes256-cbc' 'CCE-27295-5' '%s %s'

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.