Securing networks

Procedure

1. Create a playbook file, for example ~/playbook.yml, with the following content:

   ---
   - name: SSH server configuration
     hosts: managed-node-01.example.com
     tasks:
       - name: Configure sshd to prevent root and password login except from particular subnet
         ansible.builtin.include_role:
           name: rhel-system-roles.sshd
         vars:
           sshd:
             PermitRootLogin: no
             PasswordAuthentication: no
             Match:
               - Condition: "Address 192.0.2.0/24"
                 PermitRootLogin: yes
                 PasswordAuthentication: yes

   The playbook configures the managed node as an SSH server configured so that:

   • password and root user login is disabled
   • password and root user login is enabled only from the subnet 192.0.2.0/24

2. Validate the playbook syntax:

   $ ansible-playbook --syntax-check ~/playbook.yml

   Note that this command only validates the syntax and does not protect against a wrong but valid configuration.

3. Run the playbook:

   $ ansible-playbook ~/playbook.yml

Verification

1. Log in to the SSH server:

   $ ssh <username>@<ssh_server>

2. Verify the contents of the sshd_config file on the SSH server:

   $ cat /etc/ssh/sshd_config
   ...
   PasswordAuthentication no
   PermitRootLogin no
   ...
   Match Address 192.0.2.0/24
     PasswordAuthentication yes
     PermitRootLogin yes
   ...

3. Check that you can connect to the server as root from the 192.0.2.0/24 subnet:

   1. Determine your IP address:

      $ hostname -I
      192.0.2.1

      If the IP address is within the 192.0.2.1 - 192.0.2.254 range, you can connect to the server.

   2. Connect to the server as root:

      $ ssh root@<ssh_server>

Procedure

1. Create a playbook file, for example ~/playbook.yml, with the following content:

   ---
   - name: SSH client configuration
     hosts: managed-node-01.example.com
     tasks:
       - name: "Configure ssh clients"
         ansible.builtin.include_role:
           name: rhel-system-roles.ssh
         vars:
           ssh_user: root
           ssh:
             Compression: true
             GSSAPIAuthentication: no
             ControlMaster: auto
             ControlPath: ~/.ssh/.cm%C
             Host:
               - Condition: example
                 Hostname: server.example.com
                 User: user1
           ssh_ForwardX11: no

   This playbook configures the root user’s SSH client preferences on the managed nodes with the following configurations:

   • Compression is enabled.
   • ControlMaster multiplexing is set to auto.
   • The example alias for connecting to the server.example.com host is user1.
   • The example host alias is created, which represents a connection to the server.example.com host the with the user1 user name.
   • X11 forwarding is disabled.

2. Validate the playbook syntax:

   $ ansible-playbook --syntax-check ~/playbook.yml

   Note that this command only validates the syntax and does not protect against a wrong but valid configuration.

3. Run the playbook:

   $ ansible-playbook ~/playbook.yml

Procedure

1. Create a playbook file, for example ~/playbook.yml, with the following content:

   • For managed nodes that run RHEL 8 or earlier:

     ---
     - name: Non-exclusive sshd configuration
       hosts: managed-node-01.example.com
       tasks:
         - name: <Configure SSHD to accept some useful environment variables>
           ansible.builtin.include_role:
             name: rhel-system-roles.sshd
           vars:
             sshd_config_namespace: <my-application>
             sshd:
               # Environment variables to accept
               AcceptEnv:
                 LANG
                 LS_COLORS
                 EDITOR

   • For managed nodes that run RHEL 9 or later:

     - name: Non-exclusive sshd configuration
       hosts: managed-node-01.example.com
       tasks:
         - name: <Configure sshd to accept some useful environment variables>
           ansible.builtin.include_role:
             name: rhel-system-roles.sshd
           vars:
             sshd_config_file: /etc/ssh/sshd_config.d/<42-my-application>.conf
             sshd:
               # Environment variables to accept
               AcceptEnv:
                 LANG
                 LS_COLORS
                 EDITOR

     In the sshd_config_file variable, define the .conf file into which the sshd system role writes the configuration options. Use a two-digit prefix, for example 42- to specify the order in which the configuration files will be applied.

2. Validate the playbook syntax:

   $ ansible-playbook --syntax-check ~/playbook.yml

   Note that this command only validates the syntax and does not protect against a wrong but valid configuration.

3. Run the playbook:

   $ ansible-playbook ~/playbook.yml

Procedure

1. Create a playbook file, for example ~/playbook.yml, with the following content:

   - name: Host to host VPN
     hosts: managed-node-01.example.com, managed-node-02.example.com
     roles:
       - rhel-system-roles.vpn
     vars:
       vpn_connections:
         - hosts:
             managed-node-01.example.com:
             managed-node-02.example.com:
       vpn_manage_firewall: true
       vpn_manage_selinux: true

   This playbook configures the connection managed-node-01.example.com-to-managed-node-02.example.com by using pre-shared key authentication with keys auto-generated by the system role. Because vpn_manage_firewall and vpn_manage_selinux are both set to true, the vpn role uses the firewall and selinux roles to manage the ports used by the vpn role.

   To configure connections from managed hosts to external hosts that are not listed in the inventory file, add the following section to the vpn_connections list of hosts:

       vpn_connections:
         - hosts:
             managed-node-01.example.com:
             <external_node>:
               hostname: <IP_address_or_hostname>

   This configures one additional connection: managed-node-01.example.com-to-<external_node>

   Note

   The connections are configured only on the managed nodes and not on the external node.

2. Optional: You can specify multiple VPN connections for the managed nodes by using additional sections within vpn_connections, for example, a control plane and a data plane:

   - name: Multiple VPN
     hosts: managed-node-01.example.com, managed-node-02.example.com
     roles:
       - rhel-system-roles.vpn
     vars:
       vpn_connections:
         - name: control_plane_vpn
           hosts:
             managed-node-01.example.com:
               hostname: 192.0.2.0 # IP for the control plane
             managed-node-02.example.com:
               hostname: 192.0.2.1
         - name: data_plane_vpn
           hosts:
             managed-node-01.example.com:
               hostname: 10.0.0.1 # IP for the data plane
             managed-node-02.example.com:
               hostname: 10.0.0.2

3. Validate the playbook syntax:

   $ ansible-playbook --syntax-check ~/playbook.yml

   Note that this command only validates the syntax and does not protect against a wrong but valid configuration.

4. Run the playbook:

   $ ansible-playbook ~/playbook.yml

Verification

1. On the managed nodes, confirm that the connection is successfully loaded:

   # ipsec status | grep <connection_name>

   Replace <connection_name> with the name of the connection from this node, for example managed_node1-to-managed_node2.

   Note

   By default, the role generates a descriptive name for each connection it creates from the perspective of each system. For example, when creating a connection between managed_node1 and managed_node2, the descriptive name of this connection on managed_node1 is managed_node1-to-managed_node2 but on managed_node2 the connection is named managed_node2-to-managed_node1.

2. On the managed nodes, confirm that the connection is successfully started:

   # ipsec trafficstatus | grep <connection_name>

3. Optional: If a connection does not successfully load, manually add the connection by entering the following command. This provides more specific information indicating why the connection failed to establish:

   # ipsec auto --add <connection_name>

   Note

   Any errors that may occur during the process of loading and starting the connection are reported in the /var/log/pluto.log file. Because these logs are hard to parse, manually add the connection to obtain log messages from the standard output instead.

Procedure

1. Create a playbook file, for example ~/playbook.yml, with the following content:

   - name: Mesh VPN
     hosts: managed-node-01.example.com, managed-node-02.example.com, managed-node-03.example.com
     roles:
       - rhel-system-roles.vpn
     vars:
       vpn_connections:
         - opportunistic: true
           auth_method: cert
           policies:
             - policy: private
               cidr: default
             - policy: private-or-clear
               cidr: 198.51.100.0/24
             - policy: private
               cidr: 192.0.2.0/24
             - policy: clear
               cidr: 192.0.2.7/32
       vpn_manage_firewall: true
       vpn_manage_selinux: true

   Authentication with certificates is configured by defining the auth_method: cert parameter in the playbook. By default, the node name is used as the certificate nickname. In this example, this is managed-node-01.example.com. You can define different certificate names by using the cert_name attribute in your inventory.

   In this example procedure, the control node, which is the system from which you will run the Ansible playbook, shares the same classless inter-domain routing (CIDR) number as both of the managed nodes (192.0.2.0/24) and has the IP address 192.0.2.7. Therefore, the control node falls under the private policy which is automatically created for CIDR 192.0.2.0/24.

   To prevent SSH connection loss during the play, a clear policy for the control node is included in the list of policies. Note that there is also an item in the policies list where the CIDR is equal to default. This is because this playbook overrides the rule from the default policy to make it private instead of private-or-clear.

   Because vpn_manage_firewall and vpn_manage_selinux are both set to true, the vpn role uses the firewall and selinux roles to manage the ports used by the vpn role.

2. Validate the playbook syntax:

   $ ansible-playbook --syntax-check ~/playbook.yml

   Note that this command only validates the syntax and does not protect against a wrong but valid configuration.

3. Run the playbook:

   $ ansible-playbook ~/playbook.yml

Procedure

1. List the available firewall zones:

   # firewall-cmd --get-zones

   The firewall-cmd --get-zones command displays all zones that are available on the system, but it does not show any details for particular zones. To see more detailed information for all zones, use the firewall-cmd --list-all-zones command.

2. Choose the zone you want to use for this configuration.

3. Modify firewall settings for the chosen zone. For example, to allow the SSH service and remove the ftp service:

   # firewall-cmd --add-service=ssh --zone=<your_chosen_zone>
   # firewall-cmd --remove-service=ftp --zone=<same_chosen_zone>

4. Assign a network interface to the firewall zone:

   1. List the available network interfaces:

      # firewall-cmd --get-active-zones

      Activity of a zone is determined by the presence of network interfaces or source address ranges that match its configuration. The default zone is active for unclassified traffic but is not always active if no traffic matches its rules.

   2. Assign a network interface to the chosen zone:

      # firewall-cmd --zone=<your_chosen_zone> --change-interface=<interface_name> --permanent

      Assigning a network interface to a zone is more suitable for applying consistent firewall settings to all traffic on a particular interface (physical or virtual).

      The firewall-cmd command, when used with the --permanent option, often involves updating NetworkManager connection profiles to make changes to the firewall configuration permanent. This integration between firewalld and NetworkManager ensures consistent network and firewall settings.

Verification

1. Display the updated settings for your chosen zone:

   # firewall-cmd --zone=<your_chosen_zone> --list-all

   The command output displays all zone settings including the assigned services, network interface, and network connections (sources).

1. Display the current default zone:

   # firewall-cmd --get-default-zone

2. Set the new default zone:

   # firewall-cmd --set-default-zone <zone_name>

   Note

   Following this procedure, the setting is a permanent setting, even without the --permanent option.

1. List the active zones and the interfaces assigned to them:

   # firewall-cmd --get-active-zones

2. Assign the interface to a different zone:

   # firewall-cmd --zone=zone_name --change-interface=interface_name --permanent

Procedure

1. Assign the zone to the NetworkManager connection profile:

   # nmcli connection modify profile connection.zone zone_name

2. Activate the connection:

   # nmcli connection up profile

Procedure

1. Determine the path to the connection profile and its format:

   # nmcli -f NAME,FILENAME connection
   NAME    FILENAME
   enp1s0  /etc/NetworkManager/system-connections/enp1s0.nmconnection
   enp7s0  /etc/sysconfig/network-scripts/ifcfg-enp7s0

   NetworkManager uses separate directories and file names for the different connection profile formats:

   • Profiles in /etc/NetworkManager/system-connections/<connection_name>.nmconnection files use the keyfile format.
   • Profiles in /etc/sysconfig/network-scripts/ifcfg-<interface_name> files use the ifcfg format.

2. Depending on the format, update the corresponding file:

   • If the file uses the keyfile format, append zone=<name> to the [connection] section of the /etc/NetworkManager/system-connections/<connection_name>.nmconnection file:

     [connection]
     ...
     zone=internal

   • If the file uses the ifcfg format, append ZONE=<name> to the /etc/sysconfig/network-scripts/ifcfg-<interface_name> file:

     ZONE=internal

3. Reload the connection profiles:

   # nmcli connection reload

4. Reactivate the connection profiles

   # nmcli connection up <profile_name>

Procedure

1. Create a new zone:

   # firewall-cmd --permanent --new-zone=zone-name

2. Make the new zone usable:

   # firewall-cmd --reload

   The command applies recent changes to the firewall configuration without interrupting network services that are already running.

Procedure

1. Log in to the RHEL 8 web console.

   For details, see Logging in to the web console.

2. Click Networking.

3. Click on the Edit rules and zones button.

   

   If you do not see the Edit rules and zones button, log in to the web console with the administrator privileges.

4. In the Firewall section, click Add new zone.

5. In the Add zone dialog box, select a zone from the Trust level options.

   The web console displays all zones predefined in the firewalld service.

6. In the Interfaces part, select an interface or interfaces on which the selected zone is applied.

7. In the Allowed Addresses part, you can select whether the zone is applied on:

   • the whole subnet

   • or a range of IP addresses in the following format:

     • 192.168.1.0
     • 192.168.1.0/24
     • 192.168.1.0/24, 192.168.1.0

8. Click on the Add zone button.

   

Procedure

1. Log in to the RHEL 8 web console.

   For details, see Logging in to the web console.

2. Click Networking.

3. Click on the Edit rules and zones button.

   

   If you do not see the Edit rules and zones button, log in to the web console with the administrator privileges.

4. Click on the Options icon at the zone you want to remove.

   

5. Click Delete.

1. List the information for the specific zone to see the default target:

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

2. Set a new target in the zone:

   # firewall-cmd --permanent --zone=zone-name --set-target=<default|ACCEPT|REJECT|DROP>

Procedure

1. Check that the service in firewalld is not already allowed:

   # firewall-cmd --list-services
   ssh dhcpv6-client

   The command lists the services that are enabled in the default zone.

2. List all predefined services in firewalld:

   # firewall-cmd --get-services
   RH-Satellite-6 amanda-client amanda-k5-client bacula bacula-client bitcoin bitcoin-rpc bitcoin-testnet bitcoin-testnet-rpc ceph ceph-mon cfengine condor-collector ctdb dhcp dhcpv6 dhcpv6-client dns docker-registry ...

   The command displays a list of available services for the default zone.

3. Add the service to the list of services that firewalld allows:

   # firewall-cmd --add-service=<service_name>

   The command adds the specified service to the default zone.

4. Make the new settings persistent:

   # firewall-cmd --runtime-to-permanent

   The command applies these runtime changes to the permanent configuration of the firewall. By default, it applies these changes to the configuration of the default zone.

Verification

1. List all permanent firewall rules:

   # firewall-cmd --list-all --permanent
   public
     target: default
     icmp-block-inversion: no
     interfaces:
     sources:
     services: cockpit dhcpv6-client ssh
     ports:
     protocols:
     forward: no
     masquerade: no
     forward-ports:
     source-ports:
     icmp-blocks:
     rich rules:

   The command displays complete configuration with the permanent firewall rules of the default firewall zone (public).

2. Check the validity of the permanent configuration of the firewalld service.

   # firewall-cmd --check-config
   success

   If the permanent configuration is invalid, the command returns an error with further details:

   # firewall-cmd --check-config
   Error: INVALID_PROTOCOL: 'public.xml': 'tcpx' not from {'tcp'|'udp'|'sctp'|'dccp'}

   You can also manually inspect the permanent configuration files to verify the settings. The main configuration file is /etc/firewalld/firewalld.conf. The zone-specific configuration files are in the /etc/firewalld/zones/ directory and the policies are in the /etc/firewalld/policies/ directory.

Procedure

1. To enable or disable a predefined or custom service:

   1. Start the firewall-config utility and select the network zone whose services are to be configured.
   2. Select the Zones tab and then the Services tab below.
   3. Select the checkbox for each type of service you want to trust or clear the checkbox to block a service in the selected zone.

2. To edit a service:

   1. Start the firewall-config utility.
   2. Select Permanent from the menu labeled Configuration. Additional icons and menu buttons appear at the bottom of the Services window.
   3. Select the service you want to configure.

Procedure

1. Log in to the RHEL 8 web console.

   For details, see Logging in to the web console.

2. Click Networking.

3. Click on the Edit rules and zones button.

   

   If you do not see the Edit rules and zones button, log in to the web console with the administrator privileges.

4. In the Firewall section, select a zone for which you want to add the service and click Add Services.

   

5. In the Add Services dialog box, find the service you want to enable on the firewall.

6. Enable services according to your scenario:

   

7. Click Add Services.

Procedure

1. Log in to the RHEL 8 web console.

   For details, see Logging in to the web console.

2. Click Networking.

3. Click on the Edit rules and zones button.

   

   If you do not see the Edit rules and zones button, log in to the web console with the administrative privileges.

4. In the Firewall section, select a zone for which you want to configure a custom port and click Add Services.

   

5. In the Add services dialog box, click on the Custom Ports radio button.

6. In the TCP and UDP fields, add ports according to examples. You can add ports in the following formats:

   • Port numbers such as 22
   • Range of port numbers such as 5900-5910
   • Aliases such as nfs, rsync
   Note

   You can add multiple values into each field. Values must be separated with the comma and without the space, for example: 8080,8081,http

7. After adding the port number in the TCP filed, the UDP filed, or both, verify the service name in the Name field.

   The Name field displays the name of the service for which is this port reserved. You can rewrite the name if you are sure that this port is free to use and no server needs to communicate on this port.

8. In the Name field, add a name for the service including defined ports.

9. Click on the Add Ports button.

   

Procedure

1. Check the currently active firewall zone:

   # firewall-cmd --get-active-zones

2. Add the HTTPS service to the appropriate zone:

   # firewall-cmd --zone=<zone_name> --add-service=https --permanent

3. Reload the firewall configuration:

   # firewall-cmd --reload

Verification

1. Check if the port is open in firewalld:

   • If you opened the port by specifying the port number, enter:

     # firewall-cmd --zone=<zone_name> --list-all

   • If you opened the port by specifying a service definition, enter:

     # firewall-cmd --zone=<zone_name> --list-services

Procedure

1. List all allowed ports:

   # firewall-cmd --list-ports

   By default, this command lists the ports that are enabled in the default zone.

   Note

   This command will only give you a list of ports that are opened as ports. You will not be able to see any open ports that are opened as a service. For that case, consider using the --list-all option instead of --list-ports.

2. Remove the port from the list of allowed ports to close it for the incoming traffic:

   # firewall-cmd --remove-port=port-number/port-type

   This command removes a port from a zone. If you do not specify a zone, it will remove the port from the default zone.

3. Make the new settings persistent:

   # firewall-cmd --runtime-to-permanent

   Without specifying a zone, this command applies runtime changes to the permanent configuration of the default zone.

Verification

1. List the active zones and choose the zone you want to inspect:

   # firewall-cmd --get-active-zones

2. List the currently open ports in the selected zone to check if the unused or unnecessary ports are closed:

   # firewall-cmd --zone=<zone_to_inspect> --list-ports

Procedure

1. To immediately disable networking traffic, switch panic mode on:

   # firewall-cmd --panic-on

2. Switching off panic mode reverts the firewall to its permanent settings. To switch panic mode off, enter:

   # firewall-cmd --panic-off

Procedure

1. Start the firewall-config tool and select the network zone whose settings you want to change.
2. Select the Protocols tab and click the Add button on the right-hand side. The Protocol window opens.
3. Either select a protocol from the list or select the Other Protocol check box and enter the protocol in the field.

Procedure

1. List all available zones:

   # firewall-cmd --get-zones

2. Add the source IP to the trusted zone in the permanent mode:

   # firewall-cmd --zone=trusted --add-source=192.168.2.15

3. Make the new settings persistent:

   # firewall-cmd --runtime-to-permanent

Procedure

1. List allowed sources for the required zone:

   # firewall-cmd --zone=zone-name --list-sources

2. Remove the source from the zone permanently:

   # firewall-cmd --zone=zone-name --remove-source=<source>

3. Make the new settings persistent:

   # firewall-cmd --runtime-to-permanent

Procedure

1. List all available zones:

   # firewall-cmd --get-zones
   block dmz drop external home internal public trusted work

2. Add the IP range to the internal zone to route the traffic originating from the source through the zone:

   # firewall-cmd --zone=internal --add-source=192.0.2.0/24

3. Add the http service to the internal zone:

   # firewall-cmd --zone=internal --add-service=http

4. Make the new settings persistent:

   # firewall-cmd --runtime-to-permanent

Procedure

1. Create a new firewall policy:

   # firewall-cmd --permanent --new-policy podmanToAny

2. Block all traffic from Podman to other zones and allow only necessary services on Podman:

   # firewall-cmd --permanent --policy podmanToAny --set-target REJECT
   # firewall-cmd --permanent --policy podmanToAny --add-service dhcp
   # firewall-cmd --permanent --policy podmanToAny --add-service dns
   # firewall-cmd --permanent --policy podmanToAny --add-service https

3. Create a new Podman zone:

   # firewall-cmd --permanent --new-zone=podman

4. Define the ingress zone for the policy:

   # firewall-cmd --permanent --policy podmanToHost --add-ingress-zone podman

5. Define the egress zone for all other zones:

   # firewall-cmd --permanent --policy podmanToHost --add-egress-zone ANY

   Setting the egress zone to ANY means that you filter from Podman to other zones. If you want to filter to the host, then set the egress zone to HOST.

6. Restart the firewalld service:

   # systemctl restart firewalld

Procedure

1. Create a firewall policy:

   # firewall-cmd --permanent --new-policy <example_policy>

   The policies, as opposed to zones, allow packet filtering for input, output, and forwarded traffic. This is important, because forwarding traffic to endpoints on locally run web servers, containers, or virtual machines requires such capability.

2. Configure symbolic zones for the ingress and egress traffic to also enable the router itself to connect to its local IP address and forward this traffic:

   # firewall-cmd --permanent --policy=<example_policy> --add-ingress-zone=HOST
   # firewall-cmd --permanent --policy=<example_policy> --add-egress-zone=ANY

   The --add-ingress-zone=HOST option refers to packets generated locally and transmitted out of the local host. The --add-egress-zone=ANY option refers to traffic moving to any zone.

3. Add a rich rule that forwards traffic to the web server:

   # firewall-cmd --permanent --policy=<example_policy> --add-rich-rule='rule family="ipv4" destination address="192.0.2.1" forward-port port="443" protocol="tcp" to-port="443" to-addr="192.51.100.20"'

   The rich rule forwards TCP traffic from port 443 on the IP address of the router (192.0.2.1) to port 443 of the IP address of the web server (192.51.100.20).

4. Reload the firewall configuration files:

   # firewall-cmd --reload
   success

5. Activate routing of 127.0.0.0/8 in the kernel:

   • For persistent changes, run:

     # echo "net.ipv4.conf.all.route_localnet=1" > /etc/sysctl.d/90-enable-route-localnet.conf

     The command persistently configures the route_localnet kernel parameter and ensures that the setting is preserved after the system reboots.

   • For applying the settings immediately without a system reboot, run:

     # sysctl -p /etc/sysctl.d/90-enable-route-localnet.conf

     The sysctl command is useful for applying on-the-fly changes, however the configuration will not persist across system reboots.

Verification

1. Connect to the IP address of the router and to the port that you have forwarded to the web server:

   # curl https://192.0.2.1:443

2. Optional: Verify that the net.ipv4.conf.all.route_localnet kernel parameter is active:

   # sysctl net.ipv4.conf.all.route_localnet
   net.ipv4.conf.all.route_localnet = 1

3. Verify that <example_policy> is active and contains the settings you need, especially the source IP address and port, protocol to be used, and the destination IP address and port:

   # firewall-cmd --info-policy=<example_policy>
   example_policy (active)
     priority: -1
     target: CONTINUE
     ingress-zones: HOST
     egress-zones: ANY
     services:
     ports:
     protocols:
     masquerade: no
     forward-ports:
     source-ports:
     icmp-blocks:
     rich rules:
   	rule family="ipv4" destination address="192.0.2.1" forward-port port="443" protocol="tcp" to-port="443" to-addr="192.51.100.20"

Procedure

1. To check if IP masquerading is enabled (for example, for the external zone), enter the following command as root:

   # firewall-cmd --zone=external --query-masquerade

   The command prints yes with exit status 0 if enabled. It prints no with exit status 1 otherwise. If zone is omitted, the default zone will be used.

2. To enable IP masquerading, enter the following command as root:

   # firewall-cmd --zone=external --add-masquerade

3. To make this setting persistent, pass the --permanent option to the command.

4. To disable IP masquerading, enter the following command as root:

   # firewall-cmd --zone=external --remove-masquerade

   To make this setting permanent, pass the --permanent option to the command.

Procedure

1. Create the /etc/sysctl.d/90-enable-IP-forwarding.conf file with the following content:

   net.ipv4.ip_forward=1

   This setting enables IP forwarding in the kernel. It makes the internal RHEL server act as a router and forward packets from network to network.

2. Load the setting from the /etc/sysctl.d/90-enable-IP-forwarding.conf file:

   # sysctl -p /etc/sysctl.d/90-enable-IP-forwarding.conf

3. Forward incoming HTTP traffic:

   # firewall-cmd --zone=public --add-forward-port=port=80:proto=tcp:toaddr=198.51.100.10:toport=8080 --permanent

   The previous command defines a DNAT rule with the following settings:

   • --zone=public - The firewall zone for which you configure the DNAT rule. You can adjust this to whatever zone you need.
   • --add-forward-port - The option that indicates you are adding a port-forwarding rule.
   • port=80 - The external destination port.
   • proto=tcp - The protocol indicating that you forward TCP traffic.
   • toaddr=198.51.100.10 - The destination IP address.
   • toport=8080 - The destination port of the internal server.
   • --permanent - The option that makes the DNAT rule persistent across reboots.

4. Reload the firewall configuration to apply the changes:

   # firewall-cmd --reload

Procedure

1. Create the /etc/sysctl.d/90-enable-IP-forwarding.conf file with the following content:

   net.ipv4.ip_forward=1

   This setting enables IP forwarding in the kernel.

2. Load the setting from the /etc/sysctl.d/90-enable-IP-forwarding.conf file:

   # sysctl -p /etc/sysctl.d/90-enable-IP-forwarding.conf

3. Create the NAT redirect rule:

   # firewall-cmd --zone=public --add-forward-port=port=<standard_port>:proto=tcp:toport=<non_standard_port> --permanent

   The previous command defines the NAT redirect rule with the following settings:

   • --zone=public - The firewall zone, for which you configure the rule. You can adjust this to whatever zone you need.
   • --add-forward-port=port=<non_standard_port> - The option that indicates you are adding a port-forwarding (redirecting) rule with source port on which you initially receive the incoming traffic.
   • proto=tcp - The protocol indicating that you redirect TCP traffic.
   • toport=<standard_port> - The destination port, to which the incoming traffic should be redirected after being received on the source port.
   • --permanent - The option that makes the rule persist across reboots.

4. Reload the firewall configuration to apply the changes:

   # firewall-cmd --reload

Procedure

1. List available ICMP types and codes:

   # firewall-cmd --get-icmptypes
   address-unreachable bad-header beyond-scope communication-prohibited destination-unreachable echo-reply echo-request failed-policy fragmentation-needed host-precedence-violation host-prohibited host-redirect host-unknown host-unreachable
   ...

   From this predefined list, select which ICMP types and codes to allow or block.

2. Filter specific ICMP types by:

   • Allowing ICMP types:

     # firewall-cmd --zone=<target-zone> --remove-icmp-block=echo-request --permanent

     The command removes any existing blocking rules for the echo requests ICMP type.

   • Blocking ICMP types:

     # firewall-cmd --zone=<target-zone> --add-icmp-block=redirect --permanent

     The command ensures that the redirect messages ICMP type is blocked by the firewall.

3. Reload the firewall configuration to apply the changes:

   # firewall-cmd --reload

Procedure

1. Create an IP set with a meaningful name:

   # firewall-cmd --permanent --new-ipset=allowlist --type=hash:ip

   The new IP set called allowlist contains IP addresses that you want your firewall to allow.

2. Add a dynamic update to the IP set:

   # firewall-cmd --permanent --ipset=allowlist --add-entry=198.51.100.10

   This configuration updates the allowlist IP set with a newly added IP address that is allowed to pass network traffic by your firewall.

3. Create a firewall rule that references the previously created IP set:

   # firewall-cmd --permanent --zone=public --add-source=ipset:allowlist

   Without this rule, the IP set would not have any impact on network traffic. The default firewall policy would prevail.

4. Reload the firewall configuration to apply the changes:

   # firewall-cmd --reload

Verification

1. List all IP sets:

   # firewall-cmd --get-ipsets
   allowlist

2. List the active rules:

   # firewall-cmd --list-all
   public (active)
     target: default
     icmp-block-inversion: no
     interfaces: enp0s1
     sources: ipset:allowlist
     services: cockpit dhcpv6-client ssh
     ports:
     protocols:
     ...

   The sources section of the command-line output provides insights to what origins of traffic (hostnames, interfaces, IP sets, subnets, and others) are permitted or denied access to a particular firewall zone. In this case, the IP addresses contained in the allowlist IP set are allowed to pass traffic through the firewall for the public zone.

3. Explore the contents of your IP set:

   # cat /etc/firewalld/ipsets/allowlist.xml
   <?xml version="1.0" encoding="utf-8"?>
   <ipset type="hash:ip">
     <entry>198.51.100.10</entry>
   </ipset>

Procedure

1. To query whether lockdown is enabled:

   # firewall-cmd --query-lockdown

2. Manage lockdown configuration by either:

   • Enabling lockdown:

     # firewall-cmd --lockdown-on

   • Disabling lockdown:

     # firewall-cmd --lockdown-off

Procedure

1. Enable packet forwarding in the kernel:

   # echo "net.ipv4.ip_forward=1" > /etc/sysctl.d/95-IPv4-forwarding.conf
   # sysctl -p /etc/sysctl.d/95-IPv4-forwarding.conf

2. Ensure that interfaces between which you want to enable intra-zone forwarding are assigned only to the internal zone:

   # firewall-cmd --get-active-zones

3. If the interface is currently assigned to a zone other than internal, reassign it:

   # firewall-cmd --zone=internal --change-interface=interface_name --permanent

4. Add the enp1s0 and wlp0s20 interfaces to the internal zone:

   # firewall-cmd --zone=internal --add-interface=enp1s0 --add-interface=wlp0s20

5. Enable intra-zone forwarding:

   # firewall-cmd --zone=internal --add-forward

1. Log in to a host that is on the same network as the enp1s0 interface of the host on which you enabled zone forwarding.

2. Start an echo service with ncat to test connectivity:

   # ncat -e /usr/bin/cat -l 12345

3. Log in to a host that is in the same network as the wlp0s20 interface.

4. Connect to the echo server running on the host that is in the same network as the enp1s0:

   # ncat <other_host> 12345

5. Type something and press Enter. Verify the text is sent back.

Procedure

1. Create a playbook file, for example ~/playbook.yml, with the following content:

   ---
   - name: Reset firewalld example
     hosts: managed-node-01.example.com
     tasks:
       - name: Reset firewalld
         ansible.builtin.include_role:
           name: rhel-system-roles.firewall
         vars:
           firewall:
             - previous: replaced

   The settings specified in the example playbook include the following:

   previous: replaced

   Removes all existing user-defined settings and resets the firewalld settings to defaults. If you combine the previous:replaced parameter with other settings, the firewall role removes all existing settings before applying new ones.

   For details about all variables used in the playbook, see the /usr/share/ansible/roles/rhel-system-roles.firewall/README.md file on the control node.

2. Validate the playbook syntax:

   $ ansible-playbook --syntax-check ~/playbook.yml

   Note that this command only validates the syntax and does not protect against a wrong but valid configuration.

3. Run the playbook:

   $ ansible-playbook ~/playbook.yml

Procedure

1. Create a playbook file, for example ~/playbook.yml, with the following content:

   ---
   - name: Configure firewalld
     hosts: managed-node-01.example.com
     tasks:
       - name: Forward incoming traffic on port 8080 to 443
         ansible.builtin.include_role:
           name: rhel-system-roles.firewall
         vars:
           firewall:
             - forward_port: 8080/tcp;443;
               state: enabled
               runtime: true
               permanent: true

   The settings specified in the example playbook include the following:

   forward_port: 8080/tcp;443

   Traffic coming to the local port 8080 using the TCP protocol is forwarded to the port 443.

   runtime: true

   Enables changes in the runtime configuration. The default is set to true.

   For details about all variables used in the playbook, see the /usr/share/ansible/roles/rhel-system-roles.firewall/README.md file on the control node.

2. Validate the playbook syntax:

   $ ansible-playbook --syntax-check ~/playbook.yml

   Note that this command only validates the syntax and does not protect against a wrong but valid configuration.

3. Run the playbook:

   $ ansible-playbook ~/playbook.yml

Procedure

1. Create a playbook file, for example ~/playbook.yml, with the following content:

   ---
   - name: Configure firewalld
     hosts: managed-node-01.example.com
     tasks:
       - name: Creating a DMZ with access to HTTPS port and masquerading for hosts in DMZ
         ansible.builtin.include_role:
           name: rhel-system-roles.firewall
         vars:
           firewall:
             - zone: dmz
               interface: enp1s0
               service: https
               state: enabled
               runtime: true
               permanent: true

   For details about all variables used in the playbook, see the /usr/share/ansible/roles/rhel-system-roles.firewall/README.md file on the control node.

2. Validate the playbook syntax:

   $ ansible-playbook --syntax-check ~/playbook.yml

   Note that this command only validates the syntax and does not protect against a wrong but valid configuration.

3. Run the playbook:

   $ ansible-playbook ~/playbook.yml

Procedure

1. Create a table named nftables_svc with the inet address family so that the table can process both IPv4 and IPv6 packets:

   # nft add table inet nftables_svc

2. Add a base chain named INPUT, that processes incoming network traffic, to the inet nftables_svc table:

   # nft add chain inet nftables_svc INPUT { type filter hook input priority filter \; policy accept \; }

   To avoid that the shell interprets the semicolons as the end of the command, escape the semicolons using the \ character.

3. Add rules to the INPUT chain. For example, allow incoming TCP traffic on port 22 and 443, and, as the last rule of the INPUT chain, reject other incoming traffic with an Internet Control Message Protocol (ICMP) port unreachable message:

   # nft add rule inet nftables_svc INPUT tcp dport 22 accept
   # nft add rule inet nftables_svc INPUT tcp dport 443 accept
   # nft add rule inet nftables_svc INPUT reject with icmpx type port-unreachable

   If you enter the nft add rule commands as shown, nft adds the rules in the same order to the chain as you run the commands.

4. Display the current rule set including handles:

   # nft -a list table inet nftables_svc
   table inet nftables_svc { # handle 13
     chain INPUT { # handle 1
       type filter hook input priority filter; policy accept;
       tcp dport 22 accept # handle 2
       tcp dport 443 accept # handle 3
       reject # handle 4
     }
   }

5. Insert a rule before the existing rule with handle 3. For example, to insert a rule that allows TCP traffic on port 636, enter:

   # nft insert rule inet nftables_svc INPUT position 3 tcp dport 636 accept

6. Append a rule after the existing rule with handle 3. For example, to insert a rule that allows TCP traffic on port 80, enter:

   # nft add rule inet nftables_svc INPUT position 3 tcp dport 80 accept

7. Display the rule set again with handles. Verify that the later added rules have been added to the specified positions:

   # nft -a list table inet nftables_svc
   table inet nftables_svc { # handle 13
     chain INPUT { # handle 1
       type filter hook input priority filter; policy accept;
       tcp dport 22 accept # handle 2
       tcp dport 636 accept # handle 5
       tcp dport 443 accept # handle 3
       tcp dport 80 accept # handle 6
       reject # handle 4
     }
   }

8. Remove the rule with handle 6:

   # nft delete rule inet nftables_svc INPUT handle 6

   To remove a rule, you must specify the handle.

9. Display the rule set, and verify that the removed rule is no longer present:

   # nft -a list table inet nftables_svc
   table inet nftables_svc { # handle 13
     chain INPUT { # handle 1
       type filter hook input priority filter; policy accept;
       tcp dport 22 accept # handle 2
       tcp dport 636 accept # handle 5
       tcp dport 443 accept # handle 3
       reject # handle 4
     }
   }

10. Remove all remaining rules from the INPUT chain:

    # nft flush chain inet nftables_svc INPUT

11. Display the rule set, and verify that the INPUT chain is empty:

    # nft list table inet nftables_svc
    table inet nftables_svc {
      chain INPUT {
        type filter hook input priority filter; policy accept
      }
    }

12. Delete the INPUT chain:

    # nft delete chain inet nftables_svc INPUT

    You can also use this command to delete chains that still contain rules.

13. Display the rule set, and verify that the INPUT chain has been deleted:

    # nft list table inet nftables_svc
    table inet nftables_svc {
    }

14. Delete the nftables_svc table:

    # nft delete table inet nftables_svc

    You can also use this command to delete tables that still contain chains.

    Note

    To delete the entire rule set, use the nft flush ruleset command instead of manually deleting all rules, chains, and tables in separate commands.

Procedure

1. Write the iptables and ip6tables rules to a file:

   # iptables-save >/root/iptables.dump
   # ip6tables-save >/root/ip6tables.dump

2. Convert the dump files to nftables instructions:

   # iptables-restore-translate -f /root/iptables.dump > /etc/nftables/ruleset-migrated-from-iptables.nft
   # ip6tables-restore-translate -f /root/ip6tables.dump > /etc/nftables/ruleset-migrated-from-ip6tables.nft

3. Review and, if needed, manually update the generated nftables rules.

4. To enable the nftables service to load the generated files, add the following to the /etc/sysconfig/nftables.conf file:

   include "/etc/nftables/ruleset-migrated-from-iptables.nft"
   include "/etc/nftables/ruleset-migrated-from-ip6tables.nft"

5. Stop and disable the iptables service:

   # systemctl disable --now iptables

   If you used a custom script to load the iptables rules, ensure that the script no longer starts automatically and reboot to flush all tables.

6. Enable and start the nftables service:

   # systemctl enable --now nftables

Procedure

1. Edit the /etc/sysconfig/nftables.conf file.

   • If you modified the *.nft scripts that were created in /etc/nftables/ with the installation of the nftables package, uncomment the include statement for these scripts.

   • If you wrote new scripts, add include statements to include these scripts. For example, to load the /etc/nftables/example.nft script when the nftables service starts, add:

     include "/etc/nftables/_example_.nft"

2. Optional: Start the nftables service to load the firewall rules without rebooting the system:

   # systemctl start nftables

3. Enable the nftables service.

   # systemctl enable nftables

Procedure

1. Create a table:

   # nft add table nat

2. Add the prerouting and postrouting chains to the table:

   # nft add chain nat postrouting { type nat hook postrouting priority 100 \; }

   Important

   Even if you do not add a rule to the prerouting chain, the nftables framework requires this chain to match incoming packet replies.

   Note that you must pass the -- option to the nft command to prevent the shell from interpreting the negative priority value as an option of the nft command.

3. Add a rule to the postrouting chain that matches outgoing packets on the ens3 interface:

   # nft add rule nat postrouting oifname "ens3" masquerade

Procedure

1. Create a table:

   # nft add table nat

2. Add the prerouting and postrouting chains to the table:

   # nft add chain nat postrouting { type nat hook postrouting priority 100 \; }

   Important

   Even if you do not add a rule to the postrouting chain, the nftables framework requires this chain to match outgoing packet replies.

   Note that you must pass the -- option to the nft command to prevent the shell from interpreting the negative priority value as an option of the nft command.

3. Add a rule to the postrouting chain that replaces the source IP of outgoing packets through ens3 with 192.0.2.1:

   # nft add rule nat postrouting oifname "ens3" snat to 192.0.2.1

Procedure

1. Create a table:

   # nft add table nat

2. Add the prerouting and postrouting chains to the table:

   # nft -- add chain nat prerouting { type nat hook prerouting priority -100 \; }
   # nft add chain nat postrouting { type nat hook postrouting priority 100 \; }

   Important

   Even if you do not add a rule to the postrouting chain, the nftables framework requires this chain to match outgoing packet replies.

   Note that you must pass the -- option to the nft command to prevent the shell from interpreting the negative priority value as an option of the nft command.

3. Add a rule to the prerouting chain that redirects incoming traffic to port 80 and 443 on the ens3 interface of the router to the web server with the IP address 192.0.2.1:

   # nft add rule nat prerouting iifname ens3 tcp dport { 80, 443 } dnat to 192.0.2.1

4. Depending on your environment, add either a SNAT or masquerading rule to change the source address for packets returning from the web server to the sender:

   1. If the ens3 interface uses a dynamic IP addresses, add a masquerading rule:

      # nft add rule nat postrouting oifname "ens3" masquerade

   2. If the ens3 interface uses a static IP address, add a SNAT rule. For example, if the ens3 uses the 198.51.100.1 IP address:

      # nft add rule nat postrouting oifname "ens3" snat to 198.51.100.1

5. Enable packet forwarding:

   # echo "net.ipv4.ip_forward=1" > /etc/sysctl.d/95-IPv4-forwarding.conf
   # sysctl -p /etc/sysctl.d/95-IPv4-forwarding.conf